diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,86 @@ --- +## [0.18.0] - 2026-09-29 + +Module-naming systematization release: every kernel and package module moves onto a uniform +`hydra.core.*` / `hydra..*` grammar, completing the package ⊃ module ⊃ definition containment +tower. The rename touches every module, definition, and cross-host reference in the codebase; this +release exists primarily to ship it as its own coordinated batch. Also lands the translingual regex +primitive pipeline and several silent-correctness fixes in the coder layer. + +### Highlights + +- **Module-name grammar systematization** ([#729](https://github.com/CategoricalData/hydra/issues/729)): + every `hydra.*` module renamed onto a uniform package-derived prefix — kernel modules move to + `hydra.core.*`, package modules to `hydra..*` — closing the long-standing inconsistency where + a package name had no structural relationship to the module names it contained. The rename spans + every host (Haskell, Java, Python, Scala, TypeScript, all four Lisp dialects) and required fixing + stale namespace references, overlay-directory paths, and `hostOverrides` shims across every driver + and bootstrap script that had hardcoded the old grammar. Further consolidation (a structurally + enforced package↔prefix law) is tracked for 0.18.1. The kernel package itself is still published as + `hydra-kernel` (its modules are under `hydra.core.*`); the `hydra-core` package rename #729 called for + is under review because that name is taken on PyPI and npm + ([#770](https://github.com/CategoricalData/hydra/issues/770)). +- **Translingual regex primitives** ([#603](https://github.com/CategoricalData/hydra/issues/603)): + `hydra.lib.regex` primitives (`find`, `findAll`, `matches`, `replace`, `replaceAll`, `split`) now run + every pattern through the shared `hydra.regex` parse/print pipeline instead of handing raw pattern + strings to each host's native engine, so a pattern means the same thing on every host. Includes a + host-independent conformance suite and a leftmost-longest alternation fix in the PCRE/POSIX printers. +- **Silent-corruption fixes across the coder layer** + ([#744](https://github.com/CategoricalData/hydra/issues/744), + [#765](https://github.com/CategoricalData/hydra/issues/765), + [#649](https://github.com/CategoricalData/hydra/issues/649)): fixed data-corrupting bugs in the + JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the + kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and + the Python coder (silently dropping a module's types when types and terms share a file path). +- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)): + the module-reference pages under `docs/specification/` are now generated directly from the kernel + (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained. + +### New features + +- **[#603](https://github.com/CategoricalData/hydra/issues/603)** host-independent regex conformance + suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors, + grouping) across all 9 hosts. +- **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and + `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages. +- **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of + `hydra-ext` into its own first-class `hydra-rust` package. + +### Bug fixes + +- **[#744](https://github.com/CategoricalData/hydra/issues/744)** silent data corruption in + JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders for extended integer widths and map-key handling. +- **[#765](https://github.com/CategoricalData/hydra/issues/765)** kernel encode/decode generators + emitted reversed type-parameter order for 2+-param polymorphic types. +- **[#649](https://github.com/CategoricalData/hydra/issues/649)** Python coder silently dropped a + module's types when types and terms targeted the same output file path. +- **[#572](https://github.com/CategoricalData/hydra/issues/572)** TypeScript kernel-JSON test + bridge's compact-form decode heuristic mishandled nullary union arms. +- **[#761](https://github.com/CategoricalData/hydra/issues/761)** cold-seed generation ignored + `hostOverrides.java=local`, silently pulling the published Java host jar instead. +- **[#736](https://github.com/CategoricalData/hydra/issues/736)** Java build now pins JDK 11 via a + Gradle toolchain block, instead of depending on ambient `JAVA_HOME`. + +### Improvements + +- **[#327](https://github.com/CategoricalData/hydra/issues/327)** new `hydra.diff` schema-diff type + module; `Term.Inject` comparison is now by variant name. +- **[#573](https://github.com/CategoricalData/hydra/issues/573)** per-registry publish sets (Hackage, + Maven, PyPI, npm) are now derived from the package registry itself instead of 13 hand-maintained + lists — closes a recurring class of silent release-time drift. +- **[#735](https://github.com/CategoricalData/hydra/issues/735)** cross-host decimal-scale test + filtering now driven by a translingual `scaleDistinct` capability tag instead of hand-copied + per-host skip lists. + +### Documentation + +- **[#655](https://github.com/CategoricalData/hydra/issues/655)** documented the overlay-emission + "implementation wins" decision for bare primitive references (`docs/overlays.md`). + +--- + ## [0.17.7] - 2026-09-14 Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It diff --git a/hydra-ext.cabal b/hydra-ext.cabal --- a/hydra-ext.cabal +++ b/hydra-ext.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: hydra-ext -version: 0.17.7 +version: 0.18.0 synopsis: Hydra extensions: additional coders and schema integrations 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". Various extensions to Hydra category: Data @@ -27,61 +27,81 @@ library exposed-modules: - Hydra.Atlas - Hydra.Avro.Coder - Hydra.Avro.Encoder - Hydra.Avro.Environment - Hydra.Avro.Language - Hydra.Avro.Schema - Hydra.Avro.SchemaJson - Hydra.Avro.Testing - Hydra.Azure.Dtld - Hydra.Cpp.Coder - Hydra.Cpp.Environment - Hydra.Cpp.Language - Hydra.Cpp.Names - Hydra.Cpp.Serde - Hydra.Cpp.Syntax - Hydra.Cpp.Utils - Hydra.Csharp.Language - Hydra.Csharp.Syntax - Hydra.Datalog.Syntax - Hydra.Delta.Parquet - Hydra.Geojson.Model - Hydra.Graphql.Coder - Hydra.Graphql.Language - Hydra.Graphql.Serde - Hydra.Graphql.Syntax - Hydra.Iana.Linkrelations - Hydra.Json.Schema.Coder - Hydra.Json.Schema.Language - Hydra.Json.Schema.Model - Hydra.Json.Schema.Serde - Hydra.Kusto.Kql - Hydra.Osv.Schema - Hydra.Parquet.Format - Hydra.Pegasus.Coder - Hydra.Pegasus.Language - Hydra.Pegasus.Pdl - Hydra.Pegasus.Serde - Hydra.Protobuf.Any - Hydra.Protobuf.Coder - Hydra.Protobuf.Environment - Hydra.Protobuf.Language - Hydra.Protobuf.Proto3 - Hydra.Protobuf.Serde - Hydra.Protobuf.SourceContext - Hydra.Rust.Coder - Hydra.Rust.Language - Hydra.Rust.Operators - Hydra.Rust.Serde - Hydra.Rust.Syntax - Hydra.Sql.Syntax - Hydra.Stac.Items - Hydra.Workflow - Hydra.Yaml.Coder - Hydra.Yaml.Language - Hydra.Yaml.Serde + Hydra.Ext.Atlas + Hydra.Ext.Avro.Coder + Hydra.Ext.Avro.Encoder + Hydra.Ext.Avro.Environment + Hydra.Ext.Avro.Language + Hydra.Ext.Avro.Schema + Hydra.Ext.Avro.SchemaJson + Hydra.Ext.Avro.Testing + Hydra.Ext.Azure.Dtld + Hydra.Ext.Cpp.Coder + Hydra.Ext.Cpp.Environment + Hydra.Ext.Cpp.Language + Hydra.Ext.Cpp.Names + Hydra.Ext.Cpp.Serde + Hydra.Ext.Cpp.Syntax + Hydra.Ext.Cpp.Utils + Hydra.Ext.Csharp.Language + Hydra.Ext.Csharp.Syntax + Hydra.Ext.Datalog.Syntax + Hydra.Ext.Delta.Parquet + Hydra.Ext.Dsl.Atlas + Hydra.Ext.Dsl.Avro.Environment + Hydra.Ext.Dsl.Avro.Schema + Hydra.Ext.Dsl.Avro.Testing + Hydra.Ext.Dsl.Azure.Dtld + Hydra.Ext.Dsl.Cpp.Environment + Hydra.Ext.Dsl.Cpp.Syntax + Hydra.Ext.Dsl.Csharp.Syntax + Hydra.Ext.Dsl.Datalog.Syntax + Hydra.Ext.Dsl.Delta.Parquet + Hydra.Ext.Dsl.Geojson.Model + Hydra.Ext.Dsl.Graphql.Syntax + Hydra.Ext.Dsl.Iana.Linkrelations + Hydra.Ext.Dsl.Json.Schema.Model + Hydra.Ext.Dsl.Kusto.Kql + Hydra.Ext.Dsl.Osv.Schema + Hydra.Ext.Dsl.Parquet.Format + Hydra.Ext.Dsl.Pegasus.Pdl + Hydra.Ext.Dsl.Protobuf.Any + Hydra.Ext.Dsl.Protobuf.Environment + Hydra.Ext.Dsl.Protobuf.Proto3 + Hydra.Ext.Dsl.Protobuf.SourceContext + Hydra.Ext.Dsl.Sql.Syntax + Hydra.Ext.Dsl.Stac.Items + Hydra.Ext.Dsl.Workflow + Hydra.Ext.Geojson.Model + Hydra.Ext.Graphql.Coder + Hydra.Ext.Graphql.Language + Hydra.Ext.Graphql.Serde + Hydra.Ext.Graphql.Syntax + Hydra.Ext.Iana.Linkrelations + Hydra.Ext.Json.Schema.Coder + Hydra.Ext.Json.Schema.Language + Hydra.Ext.Json.Schema.Model + Hydra.Ext.Json.Schema.Serde + Hydra.Ext.Kusto.Kql + Hydra.Ext.Osv.Schema + Hydra.Ext.Parquet.Format + Hydra.Ext.Pegasus.Coder + Hydra.Ext.Pegasus.Language + Hydra.Ext.Pegasus.Pdl + Hydra.Ext.Pegasus.Serde + Hydra.Ext.Protobuf.Any + Hydra.Ext.Protobuf.Coder + Hydra.Ext.Protobuf.Environment + Hydra.Ext.Protobuf.Language + Hydra.Ext.Protobuf.Proto3 + Hydra.Ext.Protobuf.Serde + Hydra.Ext.Protobuf.SourceContext + Hydra.Ext.Sql.Syntax + Hydra.Ext.Stac.Items + Hydra.Ext.Workflow + Hydra.Ext.Yaml.Coder + Hydra.Ext.Yaml.Language + Hydra.Ext.Yaml.Serde other-modules: Paths_hydra_ext hs-source-dirs: @@ -90,7 +110,7 @@ base >=4.19.0 && <4.22 , bytestring >=0.11.5 && <0.13 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.17.7 - , hydra-rdf ==0.17.7 + , hydra-kernel ==0.18.0 + , hydra-rdf ==0.18.0 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Atlas.hs b/src/main/haskell/Hydra/Atlas.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Atlas.hs +++ /dev/null @@ -1,244 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | The Apache Atlas meta-model --- | Based on the the org.apache.atlas.model package in the master branch as of 2022-06-01 --- | https://github.com/apache/atlas/tree/master/intg/src/main/java/org/apache/atlas/model - -module Hydra.Atlas where - -import qualified Hydra.Core as Core -import qualified Hydra.Xml.Schema as Schema -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Int as I -import qualified Data.Map as M -import qualified Data.Set as S - --- | class that captures details of a struct-attribute. -data AtlasAttributeDef = - AtlasAttributeDef { - atlasAttributeDefName :: (Maybe String), - atlasAttributeDefTypeName :: (Maybe String), - atlasAttributeDefIsOptional :: Bool, - atlasAttributeDefCardinality :: (Maybe AtlasAttributeDefCardinality), - atlasAttributeDefValuesMinCount :: Int, - atlasAttributeDefValuesMaxCount :: Int, - atlasAttributeDefIsUnique :: Bool, - atlasAttributeDefIsIndexable :: Bool, - atlasAttributeDefIncludeInNotification :: Bool, - atlasAttributeDefDefaultValue :: (Maybe String), - atlasAttributeDefDescription :: (Maybe String), - atlasAttributeDefSearchWeight :: Int, - atlasAttributeDefIndexType :: (Maybe AtlasAttributeDefIndexType), - atlasAttributeDefConstraints :: [AtlasConstraintDef], - atlasAttributeDefOptions :: (M.Map String String), - atlasAttributeDefDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_AtlasAttributeDef = Core.Name "hydra.atlas.AtlasAttributeDef" - -_AtlasAttributeDef_name = Core.Name "name" - -_AtlasAttributeDef_typeName = Core.Name "typeName" - -_AtlasAttributeDef_isOptional = Core.Name "isOptional" - -_AtlasAttributeDef_cardinality = Core.Name "cardinality" - -_AtlasAttributeDef_valuesMinCount = Core.Name "valuesMinCount" - -_AtlasAttributeDef_valuesMaxCount = Core.Name "valuesMaxCount" - -_AtlasAttributeDef_isUnique = Core.Name "isUnique" - -_AtlasAttributeDef_isIndexable = Core.Name "isIndexable" - -_AtlasAttributeDef_includeInNotification = Core.Name "includeInNotification" - -_AtlasAttributeDef_defaultValue = Core.Name "defaultValue" - -_AtlasAttributeDef_description = Core.Name "description" - -_AtlasAttributeDef_searchWeight = Core.Name "searchWeight" - -_AtlasAttributeDef_indexType = Core.Name "indexType" - -_AtlasAttributeDef_constraints = Core.Name "constraints" - -_AtlasAttributeDef_options = Core.Name "options" - -_AtlasAttributeDef_displayName = Core.Name "displayName" - --- | The cardinality of an Atlas attribute: single-valued, a list, or a set -data AtlasAttributeDefCardinality = - AtlasAttributeDefCardinalitySingle | - AtlasAttributeDefCardinalityList | - AtlasAttributeDefCardinalitySet - deriving (Eq, Ord, Read, Show) - -_AtlasAttributeDefCardinality = Core.Name "hydra.atlas.AtlasAttributeDefCardinality" - -_AtlasAttributeDefCardinality_single = Core.Name "single" - -_AtlasAttributeDefCardinality_list = Core.Name "list" - -_AtlasAttributeDefCardinality_set = Core.Name "set" - --- | The index type of an Atlas attribute -data AtlasAttributeDefIndexType = - AtlasAttributeDefIndexTypeDefault | - AtlasAttributeDefIndexTypeString - deriving (Eq, Ord, Read, Show) - -_AtlasAttributeDefIndexType = Core.Name "hydra.atlas.AtlasAttributeDefIndexType" - -_AtlasAttributeDefIndexType_default = Core.Name "default" - -_AtlasAttributeDefIndexType_string = Core.Name "string" - --- | Base class that captures common-attributes for all Atlas types. -data AtlasBaseTypeDef = - AtlasBaseTypeDef { - atlasBaseTypeDefCategory :: (Maybe TypeCategory), - atlasBaseTypeDefGuid :: (Maybe String), - atlasBaseTypeDefCreatedBy :: (Maybe String), - atlasBaseTypeDefUpdatedBy :: (Maybe String), - atlasBaseTypeDefCreateTime :: (Maybe Schema.DateTime), - atlasBaseTypeDefUpdateTime :: (Maybe Schema.DateTime), - atlasBaseTypeDefVersion :: (Maybe I.Int64), - atlasBaseTypeDefName :: (Maybe String), - atlasBaseTypeDefDescription :: (Maybe String), - atlasBaseTypeDefTypeVersion :: (Maybe String), - atlasBaseTypeDefServiceType :: (Maybe String), - atlasBaseTypeDefOptions :: (M.Map String String)} - deriving (Eq, Ord, Read, Show) - -_AtlasBaseTypeDef = Core.Name "hydra.atlas.AtlasBaseTypeDef" - -_AtlasBaseTypeDef_category = Core.Name "category" - -_AtlasBaseTypeDef_guid = Core.Name "guid" - -_AtlasBaseTypeDef_createdBy = Core.Name "createdBy" - -_AtlasBaseTypeDef_updatedBy = Core.Name "updatedBy" - -_AtlasBaseTypeDef_createTime = Core.Name "createTime" - -_AtlasBaseTypeDef_updateTime = Core.Name "updateTime" - -_AtlasBaseTypeDef_version = Core.Name "version" - -_AtlasBaseTypeDef_name = Core.Name "name" - -_AtlasBaseTypeDef_description = Core.Name "description" - -_AtlasBaseTypeDef_typeVersion = Core.Name "typeVersion" - -_AtlasBaseTypeDef_serviceType = Core.Name "serviceType" - -_AtlasBaseTypeDef_options = Core.Name "options" - --- | class that captures details of a constraint. -data AtlasConstraintDef = - AtlasConstraintDef { - atlasConstraintDefType :: (Maybe String), - atlasConstraintDefParams :: (M.Map String String)} - deriving (Eq, Ord, Read, Show) - -_AtlasConstraintDef = Core.Name "hydra.atlas.AtlasConstraintDef" - -_AtlasConstraintDef_type = Core.Name "type" - -_AtlasConstraintDef_params = Core.Name "params" - --- | class that captures details of a entity-type. -data AtlasEntityDef = - AtlasEntityDef { - atlasEntityDefAsAtlasStruct :: AtlasStructDef, - atlasEntityDefSuperTypes :: (S.Set String), - -- | the value of this field is derived from 'superTypes' specified in all AtlasEntityDef - atlasEntityDefSubTypes :: (S.Set String), - -- | the value of this field is derived from all the relationshipDefs this entityType is referenced in - atlasEntityDefRelationshipAttributeDefs :: [AtlasRelationshipAttributeDef], - -- | the value of this field is derived from all the businessMetadataDefs this entityType is referenced in - atlasEntityDefBusinessAttributeDefs :: (M.Map String [AtlasAttributeDef])} - deriving (Eq, Ord, Read, Show) - -_AtlasEntityDef = Core.Name "hydra.atlas.AtlasEntityDef" - -_AtlasEntityDef_asAtlasStruct = Core.Name "asAtlasStruct" - -_AtlasEntityDef_superTypes = Core.Name "superTypes" - -_AtlasEntityDef_subTypes = Core.Name "subTypes" - -_AtlasEntityDef_relationshipAttributeDefs = Core.Name "relationshipAttributeDefs" - -_AtlasEntityDef_businessAttributeDefs = Core.Name "businessAttributeDefs" - --- | class that captures details of a struct-attribute. -data AtlasRelationshipAttributeDef = - AtlasRelationshipAttributeDef { - atlasRelationshipAttributeDefAsAtlasAttribute :: AtlasAttributeDef, - atlasRelationshipAttributeDefRelationshipTypeName :: (Maybe String), - atlasRelationshipAttributeDefIsLegacyAttribute :: Bool} - deriving (Eq, Ord, Read, Show) - -_AtlasRelationshipAttributeDef = Core.Name "hydra.atlas.AtlasRelationshipAttributeDef" - -_AtlasRelationshipAttributeDef_asAtlasAttribute = Core.Name "asAtlasAttribute" - -_AtlasRelationshipAttributeDef_relationshipTypeName = Core.Name "relationshipTypeName" - -_AtlasRelationshipAttributeDef_isLegacyAttribute = Core.Name "isLegacyAttribute" - --- | class that captures details of a struct-type. -data AtlasStructDef = - AtlasStructDef { - atlasStructDefAsAtlasBaseType :: AtlasBaseTypeDef, - atlasStructDefAttributeDefs :: [AtlasAttributeDef]} - deriving (Eq, Ord, Read, Show) - -_AtlasStructDef = Core.Name "hydra.atlas.AtlasStructDef" - -_AtlasStructDef_asAtlasBaseType = Core.Name "asAtlasBaseType" - -_AtlasStructDef_attributeDefs = Core.Name "attributeDefs" - --- | The category of an Atlas type definition -data TypeCategory = - TypeCategoryPrimitive | - TypeCategoryObjectIdType | - TypeCategoryEnum | - TypeCategoryStruct | - TypeCategoryClassification | - TypeCategoryEntity | - TypeCategoryArray | - TypeCategoryMap | - TypeCategoryRelationship | - TypeCategoryBusinessMetadata - deriving (Eq, Ord, Read, Show) - -_TypeCategory = Core.Name "hydra.atlas.TypeCategory" - -_TypeCategory_primitive = Core.Name "primitive" - -_TypeCategory_objectIdType = Core.Name "objectIdType" - -_TypeCategory_enum = Core.Name "enum" - -_TypeCategory_struct = Core.Name "struct" - -_TypeCategory_classification = Core.Name "classification" - -_TypeCategory_entity = Core.Name "entity" - -_TypeCategory_array = Core.Name "array" - -_TypeCategory_map = Core.Name "map" - -_TypeCategory_relationship = Core.Name "relationship" - -_TypeCategory_businessMetadata = Core.Name "businessMetadata" diff --git a/src/main/haskell/Hydra/Avro/Coder.hs b/src/main/haskell/Hydra/Avro/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Coder.hs +++ /dev/null @@ -1,661 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Avro-to-Hydra adapter for converting Avro schemas and data to Hydra types and terms - -module Hydra.Avro.Coder where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Avro.Environment as Environment -import qualified Hydra.Avro.Schema as Schema -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.Extract.Core as ExtractCore -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -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.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Annotate an adapter's target type with optional annotations -annotateAdapter :: Maybe (M.Map Core.Name Core.Term) -> Coders.Adapter t0 Core.Type t1 t2 t3 -> Coders.Adapter t0 Core.Type t1 t2 t3 -annotateAdapter ann ad = - Optionals.match ann ad (\n -> Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad), - Coders.adapterSource = (Coders.adapterSource ad), - Coders.adapterTarget = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Coders.adapterTarget ad), - Core.annotatedTypeAnnotation = (Core.TermMap (Maps.mapKeys (\n2 -> Core.TermVariable n2) n))})), - Coders.adapterCoder = (Coders.adapterCoder ad)}) - --- | The annotation key for foreign key metadata on an Avro field -avroForeignKey :: String -avroForeignKey = "@foreignKey" - --- | Create an adapter between Avro schemas and Hydra types/terms -avroHydraAdapter :: t0 -> Schema.Schema -> Environment.AvroEnvironment -> Either Errors.Error (Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error, Environment.AvroEnvironment) -avroHydraAdapter cx schema env0 = - - let simpleAdapter = - \env -> \typ -> \encode -> \decode -> Right ( - Coders.Adapter { - Coders.adapterIsLossy = False, - Coders.adapterSource = schema, - Coders.adapterTarget = typ, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encode, - Coders.coderDecode = decode}}, - env) - doubleToInt = \d -> Literals.bigintToInt32 (Literals.decimalToBigint d) - doubleToLong = \d -> Literals.bigintToInt64 (Literals.decimalToBigint d) - in case schema of - Schema.SchemaArray v0 -> Eithers.bind (avroHydraAdapter cx (Schema.arrayItems v0) env0) (\adEnv -> - let ad = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad), - Coders.adapterSource = schema, - Coders.adapterTarget = (Core.TypeList (Coders.adapterTarget ad)), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\v -> case v of - Model.ValueArray v1 -> Eithers.map (\ts -> Core.TermList ts) (Eithers.mapList (\jv -> Coders.coderEncode (Coders.adapterCoder ad) jv) v1)), - Coders.coderDecode = (\t -> case t of - Core.TermList v1 -> Eithers.map (\jvs -> Model.ValueArray jvs) (Eithers.mapList (\tv -> Coders.coderDecode (Coders.adapterCoder ad) tv) v1))}}, - env1))) - Schema.SchemaMap v0 -> Eithers.bind (avroHydraAdapter cx (Schema.mapValues v0) env0) (\adEnv -> - let ad = Pairs.first adEnv - env1 = Pairs.second adEnv - pairToHydra = - \entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Eithers.map (\v_ -> (Core.TermLiteral (Core.LiteralString k), v_)) (Coders.coderEncode (Coders.adapterCoder ad) v)) - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad), - Coders.adapterSource = schema, - Coders.adapterTarget = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeLiteral Core.LiteralTypeString), - Core.mapTypeValues = (Coders.adapterTarget ad)})), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\v -> case v of - Model.ValueObject v1 -> Eithers.map (\pairs -> Core.TermMap (Maps.fromList pairs)) (Eithers.mapList (\e -> pairToHydra e) v1)), - Coders.coderDecode = (\m -> Eithers.map (\mp_ -> Model.ValueObject (Maps.toList mp_)) (ExtractCore.map (\t -> ExtractCore.string (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t) (\t -> Coders.coderDecode (Coders.adapterCoder ad) t) (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) m))}}, - env1))) - Schema.SchemaNamed v0 -> - let ns = Schema.namedNamespace v0 - manns = namedAnnotationsToCore v0 - ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) - lastNs = Environment.avroEnvironmentNamespace env0 - nextNs = Optionals.match ns lastNs (\s -> Just s) - env1 = - Environment.AvroEnvironment { - Environment.avroEnvironmentNamedAdapters = (Environment.avroEnvironmentNamedAdapters env0), - Environment.avroEnvironmentNamespace = nextNs, - Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env0)} - qname = - Environment.AvroQualifiedName { - Environment.avroQualifiedNameNamespace = nextNs, - Environment.avroQualifiedNameName = (Schema.namedName v0)} - hydraName = avroNameToHydraName qname - in (Optionals.match (getAvroHydraAdapter qname env1) (Eithers.bind (case (Schema.namedType v0) of - Schema.NamedTypeEnum v1 -> - let syms = Schema.enumSymbols v1 - typ = - Core.TypeUnion (Lists.map (\s -> Core.FieldType { - Core.fieldTypeName = (Core.Name s), - Core.fieldTypeType = Core.TypeUnit}) syms) - in (simpleAdapter env1 typ (\jv -> case jv of - Model.ValueString v2 -> Right (Core.TermInject (Core.Injection { - Core.injectionTypeName = hydraName, - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name v2), - Core.fieldTerm = Core.TermUnit}}))) (\t -> case t of - Core.TermInject v2 -> - let fld = Core.injectionField v2 - fn = Core.fieldName fld - in (Right (Model.ValueString (Core.unName fn))))) - Schema.NamedTypeFixed _ -> simpleAdapter env1 (Core.TypeLiteral Core.LiteralTypeBinary) (\jv -> case jv of - Model.ValueString v2 -> Right (Core.TermLiteral (Core.LiteralBinary (Literals.base64ToBinary v2)))) (\t -> Eithers.map (\b -> Model.ValueString (Literals.binaryToBase64 b)) (ExtractCore.binary (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.NamedTypeRecord v1 -> - let avroFields = Schema.recordFields v1 - in (Eithers.bind (prepareFields cx env1 avroFields) (\prepResult -> - let adaptersByFieldName = Pairs.first prepResult - env2 = Pairs.second prepResult - in (Eithers.bind (findAvroPrimaryKeyField cx qname avroFields) (\pk -> - let encodePair = - \entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Optionals.match (Maps.lookup k adaptersByFieldName) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "unrecognized field for ", - (showQname qname), - ": ", - k])))) (\fad -> Eithers.map (\v_ -> Core.Field { - Core.fieldName = (Core.Name k), - Core.fieldTerm = v_}) (Coders.coderEncode (Coders.adapterCoder (Pairs.second fad)) v))) - decodeField = - \fld -> - let k = Core.unName (Core.fieldName fld) - v = Core.fieldTerm fld - in (Optionals.match (Maps.lookup k adaptersByFieldName) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "unrecognized field for ", - (showQname qname), - ": ", - k])))) (\fad -> Eithers.map (\v_ -> (k, v_)) (Coders.coderDecode (Coders.adapterCoder (Pairs.second fad)) v))) - lossy = - Lists.foldl (\b -> \fad -> Logic.or b (Coders.adapterIsLossy (Pairs.second fad))) False (Maps.elems adaptersByFieldName) - hfields = - Lists.map (\fad -> Core.FieldType { - Core.fieldTypeName = (Core.Name (Schema.fieldName (Pairs.first fad))), - Core.fieldTypeType = (Coders.adapterTarget (Pairs.second fad))}) (Maps.elems adaptersByFieldName) - target = Core.TypeRecord hfields - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = schema, - Coders.adapterTarget = target, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\jv -> case jv of - Model.ValueObject v2 -> Eithers.map (\fields -> Core.TermRecord (Core.Record { - Core.recordTypeName = hydraName, - Core.recordFields = fields})) (Eithers.mapList (\e -> encodePair e) v2)), - Coders.coderDecode = (\t -> case t of - Core.TermRecord v2 -> Eithers.map (\kvs -> Model.ValueObject kvs) (Eithers.mapList (\fld -> decodeField fld) (Core.recordFields v2)))}}, - env2))))))) (\adEnv2 -> - let ad = Pairs.first adEnv2 - env2 = Pairs.second adEnv2 - env3 = putAvroHydraAdapter qname ad env2 - env4 = - Environment.AvroEnvironment { - Environment.avroEnvironmentNamedAdapters = (Environment.avroEnvironmentNamedAdapters env3), - Environment.avroEnvironmentNamespace = lastNs, - Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env3)} - in (Right (annotateAdapter ann ad, env4)))) (\_ad -> err cx (Strings.concat2 "Avro named type defined more than once: " (showQname qname)))) - Schema.SchemaPrimitive v0 -> case v0 of - Schema.PrimitiveNull -> simpleAdapter env0 Core.TypeUnit (\jv -> case jv of - Model.ValueString v2 -> Right (Core.TermLiteral (Core.LiteralString v2))) (\t -> Eithers.map (\s -> Model.ValueString s) (ExtractCore.string (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveBoolean -> simpleAdapter env0 (Core.TypeLiteral Core.LiteralTypeBoolean) (\jv -> case jv of - Model.ValueBoolean v2 -> Right (Core.TermLiteral (Core.LiteralBoolean v2))) (\t -> Eithers.map (\b -> Model.ValueBoolean b) (ExtractCore.boolean (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveInt -> simpleAdapter env0 (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)) (\jv -> case jv of - Model.ValueNumber v2 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 (doubleToInt v2))))) (\t -> Eithers.map (\i -> Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint i))) (ExtractCore.int32 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveLong -> simpleAdapter env0 (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)) (\jv -> case jv of - Model.ValueNumber v2 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 (doubleToLong v2))))) (\t -> Eithers.map (\i -> Model.ValueNumber (Literals.bigintToDecimal (Literals.int64ToBigint i))) (ExtractCore.int64 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveFloat -> simpleAdapter env0 (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)) (\jv -> case jv of - Model.ValueNumber v2 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 (Literals.decimalToFloat32 v2))))) (\t -> Eithers.map (\f -> Model.ValueNumber (Literals.float32ToDecimal f)) (ExtractCore.float32 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveDouble -> simpleAdapter env0 (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)) (\jv -> case jv of - Model.ValueNumber v2 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (Literals.decimalToFloat64 v2))))) (\t -> Eithers.map (\d -> Model.ValueNumber (Literals.float64ToDecimal d)) (ExtractCore.float64 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveBytes -> simpleAdapter env0 (Core.TypeLiteral Core.LiteralTypeBinary) (\jv -> case jv of - Model.ValueString v2 -> Right (Core.TermLiteral (Core.LiteralBinary (Literals.base64ToBinary v2)))) (\t -> Eithers.map (\b -> Model.ValueString (Literals.binaryToBase64 b)) (ExtractCore.binary (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.PrimitiveString -> simpleAdapter env0 (Core.TypeLiteral Core.LiteralTypeString) (\jv -> case jv of - Model.ValueString v2 -> Right (Core.TermLiteral (Core.LiteralString v2))) (\t -> Eithers.map (\s -> Model.ValueString s) (ExtractCore.string (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) - Schema.SchemaReference v0 -> - let qname = parseAvroName (Environment.avroEnvironmentNamespace env0) v0 - in (Optionals.match (getAvroHydraAdapter qname env0) (err cx (Strings.concat2 "Referenced Avro type has not been defined: " (showQname qname))) (\ad -> Right (ad, env0))) - Schema.SchemaUnion v0 -> - let schemas = Schema.unUnion v0 - isNull = - \s -> case s of - Schema.SchemaPrimitive v1 -> case v1 of - Schema.PrimitiveNull -> True - _ -> False - _ -> False - hasNull = Logic.not (Lists.isEmpty (Lists.filter isNull schemas)) - nonNulls = Lists.filter (\s -> Logic.not (isNull s)) schemas - forOptional = - \s -> Eithers.bind (avroHydraAdapter cx s env0) (\adEnv -> - let ad = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad), - Coders.adapterSource = schema, - Coders.adapterTarget = (Core.TypeOptional (Coders.adapterTarget ad)), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\v -> case v of - Model.ValueNull -> Right (Core.TermOptional Nothing) - _ -> Eithers.map (\t -> Core.TermOptional (Just t)) (Coders.coderEncode (Coders.adapterCoder ad) v)), - Coders.coderDecode = (\t -> case t of - Core.TermOptional v1 -> Optionals.match v1 (Right Model.ValueNull) (\term_ -> Coders.coderDecode (Coders.adapterCoder ad) term_))}}, - env1))) - in (Logic.ifElse (Ordering.gt (Lists.length nonNulls) 1) (err cx "general-purpose unions are not yet supported") (Optionals.match (Lists.head nonNulls) (err cx "cannot generate the empty type") (\nonNullHead -> Logic.ifElse hasNull (forOptional nonNullHead) (Eithers.bind (avroHydraAdapter cx nonNullHead env0) (\adEnv -> - let ad = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad), - Coders.adapterSource = schema, - Coders.adapterTarget = (Coders.adapterTarget ad), - Coders.adapterCoder = (Coders.adapterCoder ad)}, - env1))))))) - --- | Convert an Avro qualified name to a Hydra name -avroNameToHydraName :: Environment.AvroQualifiedName -> Core.Name -avroNameToHydraName qname = - - let mns = Environment.avroQualifiedNameNamespace qname - local = Environment.avroQualifiedNameName qname - in (Names.unqualifyName (Util.QualifiedName { - Util.qualifiedNameModuleName = (Optionals.map (\s -> Packaging.ModuleName s) mns), - Util.qualifiedNameLocal = local})) - --- | The annotation key for primary key metadata on an Avro field -avroPrimaryKey :: String -avroPrimaryKey = "@primaryKey" - --- | An empty Avro environment with no named adapters, no namespace, and no elements -emptyAvroEnvironment :: Environment.AvroEnvironment -emptyAvroEnvironment = - Environment.AvroEnvironment { - Environment.avroEnvironmentNamedAdapters = Maps.empty, - Environment.avroEnvironmentNamespace = Nothing, - Environment.avroEnvironmentElements = Maps.empty} - --- | Encode a JSON value as a Hydra term for annotation purposes -encodeAnnotationValue :: Model.Value -> Core.Term -encodeAnnotationValue v = - case v of - Model.ValueArray v0 -> Core.TermList (Lists.map encodeAnnotationValue v0) - Model.ValueBoolean v0 -> Core.TermLiteral (Core.LiteralBoolean v0) - Model.ValueNull -> Core.TermUnit - Model.ValueNumber v0 -> Core.TermLiteral (Core.LiteralDecimal v0) - Model.ValueObject v0 -> Core.TermMap (Maps.fromList (Lists.map (\entry -> - let k = Pairs.first entry - v_ = Pairs.second entry - in (Core.TermLiteral (Core.LiteralString k), (encodeAnnotationValue v_))) v0)) - Model.ValueString v0 -> Core.TermLiteral (Core.LiteralString v0) - --- | Construct an error result with a message in context -err :: t0 -> String -> Either Errors.Error t1 -err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) - --- | Extract a JSON array or return an error -expectArrayE :: t0 -> Model.Value -> Either t1 [Model.Value] -expectArrayE cx value = - case value of - Model.ValueArray v0 -> Right v0 - --- | Extract a JSON object or return an error -expectObjectE :: t0 -> Model.Value -> Either t1 (M.Map String Model.Value) -expectObjectE cx value = - case value of - Model.ValueObject v0 -> Right (Maps.fromList v0) - --- | Extract a JSON string or return an error -expectStringE :: t0 -> Model.Value -> Either t1 String -expectStringE cx value = - case value of - Model.ValueString v0 -> Right v0 - --- | Extract field annotations and convert them to core Name/Term pairs -fieldAnnotationsToCore :: Schema.Field -> M.Map Core.Name Core.Term -fieldAnnotationsToCore f = - Maps.fromList (Lists.map (\entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Core.Name k, (encodeAnnotationValue v))) (Maps.toList (Schema.fieldAnnotations f))) - --- | Find the primary key field among a list of Avro fields -findAvroPrimaryKeyField :: t0 -> Environment.AvroQualifiedName -> [Schema.Field] -> Either Errors.Error (Maybe Environment.AvroPrimaryKey) -findAvroPrimaryKeyField cx qname avroFields = - - let keys = Optionals.givens (Lists.map (\f -> primaryKeyE cx f) avroFields) - in (Logic.ifElse (Lists.isEmpty keys) (Right Nothing) (Logic.ifElse (Equality.equal (Lists.length keys) 1) (Right (Lists.head keys)) (err cx (Strings.concat2 "multiple primary key fields for " (showQname qname))))) - --- | Extract a foreign key annotation from a field, if present -foreignKeyE :: t0 -> Schema.Field -> Either Errors.Error (Maybe Environment.AvroForeignKey) -foreignKeyE cx f = - Optionals.match (Maps.lookup avroForeignKey (Schema.fieldAnnotations f)) (Right Nothing) (\v -> Eithers.bind (expectObjectE cx v) (\m -> Eithers.bind (Eithers.map (\s -> Core.Name s) (requireStringE cx "type" m)) (\tname -> Eithers.bind (optStringE cx "pattern" m) (\pattern_ -> - let constr = Optionals.match pattern_ (\s -> Core.Name s) (\pat -> patternToNameConstructor pat) - in (Right (Just (Environment.AvroForeignKey { - Environment.avroForeignKeyTypeName = tname, - Environment.avroForeignKeyConstructor = constr}))))))) - --- | Look up an adapter by qualified name in the environment -getAvroHydraAdapter :: Environment.AvroQualifiedName -> Environment.AvroEnvironment -> Maybe (Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error) -getAvroHydraAdapter qname env = Maps.lookup qname (Environment.avroEnvironmentNamedAdapters env) - --- | Convert a JSON value to a string, supporting booleans, strings, and numbers -jsonToStringE :: t0 -> Model.Value -> Either Errors.Error String -jsonToStringE cx v = - case v of - Model.ValueBoolean v0 -> Right (Logic.ifElse v0 "true" "false") - Model.ValueString v0 -> Right v0 - Model.ValueNumber v0 -> Right (Literals.printDecimal v0) - _ -> unexpectedE cx "string, number, or boolean" "other" - --- | Extract named type annotations and convert them to core Name/Term pairs -namedAnnotationsToCore :: Schema.Named -> M.Map Core.Name Core.Term -namedAnnotationsToCore n = - Maps.fromList (Lists.map (\entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Core.Name k, (encodeAnnotationValue v))) (Maps.toList (Schema.namedAnnotations n))) - --- | Look up an optional string attribute in a JSON object map -optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe String)) -optStringE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) - --- | Parse a dotted Avro name into a qualified name -parseAvroName :: Maybe String -> String -> Environment.AvroQualifiedName -parseAvroName mns name_ = - - let parts = Strings.splitOn "." name_ - local = Optionals.withDefault name_ (Lists.last parts) - in (Logic.ifElse (Equality.equal (Lists.length parts) 1) (Environment.AvroQualifiedName { - Environment.avroQualifiedNameNamespace = mns, - Environment.avroQualifiedNameName = local}) (Environment.AvroQualifiedName { - Environment.avroQualifiedNameNamespace = (Optionals.map (\ps -> Strings.join "." ps) (Lists.init parts)), - Environment.avroQualifiedNameName = local})) - --- | Create a name constructor from a pattern string -patternToNameConstructor :: String -> String -> Core.Name -patternToNameConstructor pat s = Core.Name (Strings.join s (Strings.splitOn "${}" pat)) - --- | Prepare a single field, producing an adapter and updated environment -prepareField :: t0 -> Environment.AvroEnvironment -> Schema.Field -> Either Errors.Error ( - (String, (Schema.Field, (Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error))), - Environment.AvroEnvironment) -prepareField cx env f = - - let manns = fieldAnnotationsToCore f - ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) - in (Eithers.bind (foreignKeyE cx f) (\fk -> Eithers.bind (Optionals.match fk (avroHydraAdapter cx (Schema.fieldType f) env) (\fkVal -> - let fkName = Environment.avroForeignKeyTypeName fkVal - fkConstr = Environment.avroForeignKeyConstructor fkVal - in (Eithers.bind (avroHydraAdapter cx (Schema.fieldType f) env) (\adEnvPair -> - let ad0 = Pairs.first adEnvPair - env1 = Pairs.second adEnvPair - elTyp = Core.TypeVariable fkName - encodeValue = - \v -> Eithers.bind (Coders.coderEncode (Coders.adapterCoder ad0) v) (\encoded -> Eithers.bind (termToStringE cx encoded) (\s -> Right (Core.TermVariable (fkConstr s)))) - decodeTerm = - \t -> case t of - Core.TermVariable v0 -> Eithers.bind (stringToTermE cx (Coders.adapterTarget ad0) (Core.unName v0)) (\term_ -> Coders.coderDecode (Coders.adapterCoder ad0) term_) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected variable")) - forTypeAndCoder = - \env2 -> \ad1 -> \typ -> \cdr -> Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy ad1), - Coders.adapterSource = (Schema.fieldType f), - Coders.adapterTarget = typ, - Coders.adapterCoder = cdr}, - env2) - in case (Strip.deannotateType (Coders.adapterTarget ad0)) of - Core.TypeOptional v0 -> case v0 of - Core.TypeLiteral _ -> forTypeAndCoder env1 ad0 (Core.TypeOptional elTyp) (Coders.Coder { - Coders.coderEncode = (\json -> Eithers.map (\v_ -> Core.TermOptional (Just v_)) (encodeValue json)), - Coders.coderDecode = decodeTerm}) - _ -> err cx "expected literal type inside optional foreign key" - Core.TypeList v0 -> case v0 of - Core.TypeLiteral _ -> forTypeAndCoder env1 ad0 (Core.TypeList elTyp) (Coders.Coder { - Coders.coderEncode = (\json -> case json of - Model.ValueArray v2 -> Eithers.map (\terms -> Core.TermList terms) (Eithers.mapList (\jv -> encodeValue jv) v2) - _ -> Left (Errors.ErrorOther (Errors.OtherError "Expected JSON array"))), - Coders.coderDecode = decodeTerm}) - _ -> err cx "expected literal type inside list foreign key" - Core.TypeLiteral _ -> forTypeAndCoder env1 ad0 elTyp (Coders.Coder { - Coders.coderEncode = encodeValue, - Coders.coderDecode = decodeTerm}) - _ -> err cx (Strings.concat2 "unsupported type annotated as foreign key: " "unknown"))))) (\adEnv -> - let ad = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ((Schema.fieldName f, (f, (annotateAdapter ann ad))), env1))))) - --- | Thread AvroEnvironment through preparing multiple fields -prepareFields :: t0 -> Environment.AvroEnvironment -> [Schema.Field] -> Either Errors.Error ( - M.Map String (Schema.Field, (Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error)), - Environment.AvroEnvironment) -prepareFields cx env fields = - Lists.foldl (\acc -> \f -> Eithers.bind acc (\accPair -> - let m = Pairs.first accPair - env1 = Pairs.second accPair - in (Eithers.bind (prepareField cx env1 f) (\result -> - let kv = Pairs.first result - env2 = Pairs.second result - k = Pairs.first kv - v = Pairs.second kv - in (Right (Maps.insert k v m, env2)))))) (Right (Maps.empty, env)) fields - --- | Extract a primary key annotation from a field, if present -primaryKeyE :: t0 -> Schema.Field -> Maybe Environment.AvroPrimaryKey -primaryKeyE cx f = - Optionals.match (Maps.lookup avroPrimaryKey (Schema.fieldAnnotations f)) Nothing (\v -> Eithers.either (\_ -> Nothing) (\s -> Just (Environment.AvroPrimaryKey { - Environment.avroPrimaryKeyFieldName = (Core.Name (Schema.fieldName f)), - Environment.avroPrimaryKeyConstructor = (patternToNameConstructor s)})) (expectStringE cx v)) - --- | Store an adapter in the environment by qualified name -putAvroHydraAdapter :: Environment.AvroQualifiedName -> Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error -> Environment.AvroEnvironment -> Environment.AvroEnvironment -putAvroHydraAdapter qname ad env = - Environment.AvroEnvironment { - Environment.avroEnvironmentNamedAdapters = (Maps.insert qname ad (Environment.avroEnvironmentNamedAdapters env)), - Environment.avroEnvironmentNamespace = (Environment.avroEnvironmentNamespace env), - Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env)} - --- | Look up a required string attribute in a JSON object map -requireStringE :: t0 -> String -> M.Map String Model.Value -> Either Errors.Error String -requireStringE cx fname m = - Optionals.match (Maps.lookup fname m) (err cx (Strings.concat [ - "required attribute ", - (Literals.printString fname), - " not found"])) (\v -> expectStringE cx v) - --- | Recursively rewrite an Avro schema using a monadic transformation function -rewriteAvroSchemaM :: ((Schema.Schema -> Either t0 Schema.Schema) -> Schema.Schema -> Either t0 Schema.Schema) -> Schema.Schema -> Either t0 Schema.Schema -rewriteAvroSchemaM f schema = - - let recurse = rewriteAvroSchemaM f - fsub = - \s -> case s of - Schema.SchemaArray v0 -> Eithers.map (\els_ -> Schema.SchemaArray (Schema.Array { - Schema.arrayItems = els_})) (recurse (Schema.arrayItems v0)) - Schema.SchemaMap v0 -> Eithers.map (\vs_ -> Schema.SchemaMap (Schema.Map { - Schema.mapValues = vs_})) (recurse (Schema.mapValues v0)) - Schema.SchemaNamed v0 -> Eithers.map (\nt_ -> Schema.SchemaNamed (Schema.Named { - Schema.namedName = (Schema.namedName v0), - Schema.namedNamespace = (Schema.namedNamespace v0), - Schema.namedAliases = (Schema.namedAliases v0), - Schema.namedDoc = (Schema.namedDoc v0), - Schema.namedType = nt_, - Schema.namedAnnotations = (Schema.namedAnnotations v0)})) (case (Schema.namedType v0) of - Schema.NamedTypeRecord v1 -> Eithers.map (\fields_ -> Schema.NamedTypeRecord (Schema.Record { - Schema.recordFields = fields_})) (Eithers.mapList (\fld -> Eithers.map (\t_ -> Schema.Field { - Schema.fieldName = (Schema.fieldName fld), - Schema.fieldDoc = (Schema.fieldDoc fld), - Schema.fieldType = t_, - Schema.fieldDefault = (Schema.fieldDefault fld), - Schema.fieldOrder = (Schema.fieldOrder fld), - Schema.fieldAliases = (Schema.fieldAliases fld), - Schema.fieldAnnotations = (Schema.fieldAnnotations fld)}) (recurse (Schema.fieldType fld))) (Schema.recordFields v1)) - _ -> Right (Schema.namedType v0)) - Schema.SchemaUnion v0 -> Eithers.map (\schemas_ -> Schema.SchemaUnion (Schema.Union schemas_)) (Eithers.mapList (\us -> recurse us) (Schema.unUnion v0)) - _ -> Right s - in (f fsub schema) - --- | Convert an Avro qualified name to a display string -showQname :: Environment.AvroQualifiedName -> String -showQname qname = - - let mns = Environment.avroQualifiedNameNamespace qname - local = Environment.avroQualifiedNameName qname - in (Strings.concat2 (Optionals.match mns "" (\ns -> Strings.concat2 ns ".")) local) - --- | Parse a string into a term of the expected type -stringToTermE :: t0 -> Core.Type -> String -> Either Errors.Error Core.Term -stringToTermE cx typ s = - - let readErr = err cx "failed to read value" - readAndWrap = \reader -> \wrapper -> Optionals.match (reader s) readErr (\v -> Right (Core.TermLiteral (wrapper v))) - in case (Strip.deannotateType typ) of - Core.TypeLiteral v0 -> case v0 of - Core.LiteralTypeBoolean -> readAndWrap (\x -> Literals.parseBoolean x) (\b -> Core.LiteralBoolean b) - Core.LiteralTypeInteger v1 -> case v1 of - Core.IntegerTypeBigint -> readAndWrap (\x -> Literals.parseBigint x) (\i -> Core.LiteralInteger (Core.IntegerValueBigint i)) - Core.IntegerTypeInt8 -> readAndWrap (\x -> Literals.parseInt8 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt8 i)) - Core.IntegerTypeInt16 -> readAndWrap (\x -> Literals.parseInt16 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt16 i)) - Core.IntegerTypeInt32 -> readAndWrap (\x -> Literals.parseInt32 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt32 i)) - Core.IntegerTypeInt64 -> readAndWrap (\x -> Literals.parseInt64 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt64 i)) - Core.IntegerTypeUint8 -> readAndWrap (\x -> Literals.parseUint8 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint8 i)) - Core.IntegerTypeUint16 -> readAndWrap (\x -> Literals.parseUint16 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint16 i)) - Core.IntegerTypeUint32 -> readAndWrap (\x -> Literals.parseUint32 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint32 i)) - Core.IntegerTypeUint64 -> readAndWrap (\x -> Literals.parseUint64 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint64 i)) - Core.LiteralTypeString -> Right (Core.TermLiteral (Core.LiteralString s)) - _ -> unexpectedE cx "literal type" "other literal type" - _ -> unexpectedE cx "literal type" "other" - --- | Convert a literal term to its string representation -termToStringE :: t0 -> Core.Term -> Either Errors.Error String -termToStringE cx term = - case (Strip.deannotateTerm term) of - Core.TermLiteral v0 -> case v0 of - Core.LiteralBoolean v1 -> Right (Literals.printBoolean v1) - Core.LiteralInteger v1 -> Right (case v1 of - Core.IntegerValueBigint v2 -> Literals.printBigint v2 - Core.IntegerValueInt8 v2 -> Literals.printInt8 v2 - Core.IntegerValueInt16 v2 -> Literals.printInt16 v2 - Core.IntegerValueInt32 v2 -> Literals.printInt32 v2 - Core.IntegerValueInt64 v2 -> Literals.printInt64 v2 - Core.IntegerValueUint8 v2 -> Literals.printUint8 v2 - Core.IntegerValueUint16 v2 -> Literals.printUint16 v2 - Core.IntegerValueUint32 v2 -> Literals.printUint32 v2 - Core.IntegerValueUint64 v2 -> Literals.printUint64 v2) - Core.LiteralString v1 -> Right v1 - _ -> unexpectedE cx "boolean, integer, or string" "other literal" - Core.TermOptional v0 -> Optionals.match v0 (unexpectedE cx "literal value" "Nothing") (\term_ -> termToStringE cx term_) - _ -> unexpectedE cx "literal value" "other" - --- | Construct an error for unexpected values -unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 -unexpectedE cx expected found = - err cx (Strings.concat [ - "Expected ", - expected, - ", found: ", - found]) diff --git a/src/main/haskell/Hydra/Avro/Encoder.hs b/src/main/haskell/Hydra/Avro/Encoder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Encoder.hs +++ /dev/null @@ -1,605 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Hydra-to-Avro encoder: converts Hydra types and terms to Avro schemas and JSON values - -module Hydra.Avro.Encoder where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Ast as Ast -import qualified Hydra.Avro.Environment as Environment -import qualified Hydra.Avro.Schema as Schema -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.Extract.Core as ExtractCore -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Build an Avro field from a name-adapter pair -buildAvroField :: (Core.Name, (Coders.Adapter t0 Schema.Schema t1 t2 t3)) -> Schema.Field -buildAvroField nameAd = - - let name_ = Pairs.first nameAd - ad = Pairs.second nameAd - in Schema.Field { - Schema.fieldName = (localName name_), - Schema.fieldDoc = Nothing, - Schema.fieldType = (Coders.adapterTarget ad), - Schema.fieldDefault = Nothing, - Schema.fieldOrder = Nothing, - Schema.fieldAliases = Nothing, - Schema.fieldAnnotations = Maps.empty} - --- | Create an empty encode environment with the given type map -emptyEncodeEnvironment :: M.Map Core.Name Core.Type -> Environment.EncodeEnvironment -emptyEncodeEnvironment typeMap = - Environment.EncodeEnvironment { - Environment.encodeEnvironmentTypeMap = typeMap, - Environment.encodeEnvironmentEmitted = Maps.empty} - --- | Encode a Hydra type to an Avro schema adapter, given the type map and a root name -encodeType :: t0 -> M.Map Core.Name Core.Type -> Core.Name -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error) -encodeType cx typeMap name_ = - Eithers.map (\adEnv -> Pairs.first adEnv) (encodeTypeWithEnv cx name_ (emptyEncodeEnvironment typeMap)) - --- | Core encoding logic: recursively encode a Hydra type to an Avro schema -encodeTypeInner :: t0 -> Maybe Core.Name -> Core.Type -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error, Environment.EncodeEnvironment) -encodeTypeInner cx mName typ env = - - let annResult = extractAnnotations typ - annotations = Pairs.first annResult - bareType = Pairs.second annResult - simpleAdapter = - \target -> \lossy -> \encode -> \decode -> Right ( - Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = typ, - Coders.adapterTarget = target, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encode, - Coders.coderDecode = decode}}, - env) - in case bareType of - Core.TypeUnit -> simpleAdapter (Schema.SchemaPrimitive Schema.PrimitiveNull) False (\_t -> Right Model.ValueNull) (\_j -> Right Core.TermUnit) - Core.TypeLiteral v0 -> Eithers.map (\ad -> (ad, env)) (literalAdapter cx typ v0) - Core.TypeList v0 -> Eithers.bind (encodeTypeInner cx Nothing v0 env) (\adEnv -> - let innerAd = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy innerAd), - Coders.adapterSource = typ, - Coders.adapterTarget = (Schema.SchemaArray (Schema.Array { - Schema.arrayItems = (Coders.adapterTarget innerAd)})), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\t -> case t of - Core.TermList v1 -> Eithers.map (\jvs -> Model.ValueArray jvs) (Eithers.mapList (\el -> Coders.coderEncode (Coders.adapterCoder innerAd) el) v1)), - Coders.coderDecode = (\j -> case j of - Model.ValueArray v1 -> Eithers.map (\ts -> Core.TermList ts) (Eithers.mapList (\el -> Coders.coderDecode (Coders.adapterCoder innerAd) el) v1))}}, - env1))) - Core.TypeMap v0 -> - let keyType = Core.mapTypeKeys v0 - valType = Core.mapTypeValues v0 - in case (Strip.deannotateType keyType) of - Core.TypeLiteral v1 -> case v1 of - Core.LiteralTypeString -> Eithers.bind (encodeTypeInner cx Nothing valType env) (\adEnv -> - let valAd = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy valAd), - Coders.adapterSource = typ, - Coders.adapterTarget = (Schema.SchemaMap (Schema.Map { - Schema.mapValues = (Coders.adapterTarget valAd)})), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\t -> case t of - Core.TermMap v3 -> - let encodeEntry = - \entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Eithers.bind (ExtractCore.string (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) k) (\kStr -> Eithers.map (\vJson -> (kStr, vJson)) (Coders.coderEncode (Coders.adapterCoder valAd) v))) - in (Eithers.map (\pairs -> Model.ValueObject pairs) (Eithers.mapList encodeEntry (Maps.toList v3)))), - Coders.coderDecode = (\j -> case j of - Model.ValueObject v3 -> - let decodeEntry = - \entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Eithers.map (\vTerm -> (Core.TermLiteral (Core.LiteralString k), vTerm)) (Coders.coderDecode (Coders.adapterCoder valAd) v)) - in (Eithers.map (\pairs -> Core.TermMap (Maps.fromList pairs)) (Eithers.mapList decodeEntry v3)))}}, - env1))) - _ -> err cx "Avro maps require string keys" - _ -> err cx "Avro maps require string keys" - Core.TypeRecord v0 -> namedTypeAdapter cx typ mName annotations v0 env (\avroFields -> Schema.NamedTypeRecord (Schema.Record { - Schema.recordFields = avroFields})) recordTermCoder - Core.TypeUnion v0 -> - let allUnit = - Lists.foldl (\b -> \ft -> Logic.and b (case (Core.fieldTypeType ft) of - Core.TypeUnit -> True - _ -> False)) True v0 - in (Logic.ifElse allUnit (enumAdapter cx typ mName annotations v0 env) (unionAsRecordAdapter cx typ mName annotations v0 env)) - Core.TypeOptional v0 -> Eithers.bind (encodeTypeInner cx Nothing v0 env) (\adEnv -> - let innerAd = Pairs.first adEnv - env1 = Pairs.second adEnv - in (Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy innerAd), - Coders.adapterSource = typ, - Coders.adapterTarget = (Schema.SchemaUnion (Schema.Union [ - Schema.SchemaPrimitive Schema.PrimitiveNull, - (Coders.adapterTarget innerAd)])), - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\t -> case t of - Core.TermOptional v1 -> Optionals.match v1 (Right Model.ValueNull) (\inner -> Coders.coderEncode (Coders.adapterCoder innerAd) inner)), - Coders.coderDecode = (\j -> case j of - Model.ValueNull -> Right (Core.TermOptional Nothing) - _ -> Eithers.map (\t -> Core.TermOptional (Just t)) (Coders.coderDecode (Coders.adapterCoder innerAd) j))}}, - env1))) - Core.TypeWrap v0 -> encodeTypeInner cx mName v0 env - Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 (Environment.encodeEnvironmentEmitted env)) (Optionals.match (Maps.lookup v0 (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.concat2 "referenced type not found: " (Core.unName v0))) (\refType -> encodeTypeInner cx (Just v0) refType env)) (\existingAd -> Right ( - Coders.Adapter { - Coders.adapterIsLossy = (Coders.adapterIsLossy existingAd), - Coders.adapterSource = (Coders.adapterSource existingAd), - Coders.adapterTarget = (Schema.SchemaReference (localName v0)), - Coders.adapterCoder = (Coders.adapterCoder existingAd)}, - env)) - _ -> err cx "unsupported Hydra type for Avro encoding" - --- | Encode with full environment threading. Returns the adapter and updated environment -encodeTypeWithEnv :: t0 -> Core.Name -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error, Environment.EncodeEnvironment) -encodeTypeWithEnv cx name_ env = - Optionals.match (Maps.lookup name_ (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.concat2 "type not found in type map: " (Literals.printString (Core.unName name_)))) (\typ -> encodeTypeInner cx (Just name_) typ env) - --- | Adapter for all-unit union types (enums) -enumAdapter :: t0 -> Core.Type -> Maybe Core.Name -> M.Map Core.Name Core.Term -> [Core.FieldType] -> Environment.EncodeEnvironment -> Either t1 (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error, Environment.EncodeEnvironment) -enumAdapter cx typ mName annotations fieldTypes env0 = - - let symbols = Lists.map (\ft -> localName (Core.fieldTypeName ft)) fieldTypes - typeName = Optionals.withDefault (typeToName typ) mName - avroAnnotations = hydraAnnotationsToAvro annotations - avroSchema = - Schema.SchemaNamed (Schema.Named { - Schema.namedName = (localName typeName), - Schema.namedNamespace = (nameNamespace typeName), - Schema.namedAliases = Nothing, - Schema.namedDoc = Nothing, - Schema.namedType = (Schema.NamedTypeEnum (Schema.Enum { - Schema.enumSymbols = symbols, - Schema.enumDefault = Nothing})), - Schema.namedAnnotations = avroAnnotations}) - adapter_ = - Coders.Adapter { - Coders.adapterIsLossy = False, - Coders.adapterSource = typ, - Coders.adapterTarget = avroSchema, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\t -> case t of - Core.TermInject v0 -> - let fname = Core.injectionField v0 - in (Right (Model.ValueString (localName (Core.fieldName fname)))) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected union term for enum"))), - Coders.coderDecode = (\j -> case j of - Model.ValueString v0 -> Right (Core.TermInject (Core.Injection { - Core.injectionTypeName = typeName, - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name v0), - Core.fieldTerm = Core.TermUnit}})))}} - env1 = - Environment.EncodeEnvironment { - Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env0), - Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env0))} - in (Right (adapter_, env1)) - --- | Construct an error result with a message in context -err :: t0 -> String -> Either Errors.Error t1 -err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) - --- | Extract annotations from a potentially annotated type -extractAnnotations :: Core.Type -> (M.Map Core.Name Core.Term, Core.Type) -extractAnnotations typ = - case typ of - Core.TypeAnnotated v0 -> - let inner = Core.annotatedTypeBody v0 - anns = Annotations.getAnnotationMap (Core.annotatedTypeAnnotation v0) - innerResult = extractAnnotations inner - innerAnns = Pairs.first innerResult - bareType = Pairs.second innerResult - in (Maps.union anns innerAnns, bareType) - _ -> (Maps.empty, typ) - --- | Create an adapter for float types -floatAdapter :: t0 -> t1 -> Core.FloatType -> Either t2 (Coders.Adapter t1 Schema.Schema Core.Term Model.Value Errors.Error) -floatAdapter cx typ ft = - - let simple = - \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = typ, - Coders.adapterTarget = target, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encode, - Coders.coderDecode = decode}}) - in case ft of - Core.FloatTypeFloat32 -> simple (Schema.SchemaPrimitive Schema.PrimitiveFloat) False (\t -> Eithers.map (\f -> Model.ValueNumber (Literals.float32ToDecimal f)) (ExtractCore.float32 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of - Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 (Literals.decimalToFloat32 v1))))) - Core.FloatTypeFloat64 -> simple (Schema.SchemaPrimitive Schema.PrimitiveDouble) False (\t -> Eithers.map (\d -> Model.ValueNumber (Literals.float64ToDecimal d)) (ExtractCore.float64 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of - Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (Literals.decimalToFloat64 v1))))) - _ -> simple (Schema.SchemaPrimitive Schema.PrimitiveDouble) True (\t -> case t of - Core.TermLiteral v0 -> case v0 of - Core.LiteralFloat v1 -> Right (Model.ValueNumber (floatValueToDouble v1))) (\j -> case j of - Model.ValueNumber v0 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (Literals.decimalToFloat64 v0))))) - --- | Convert any float value to a JSON decimal number -floatValueToDouble :: Core.FloatValue -> Sci.Scientific -floatValueToDouble fv = - case fv of - Core.FloatValueFloat32 v0 -> Literals.float32ToDecimal v0 - Core.FloatValueFloat64 v0 -> Literals.float64ToDecimal v0 - --- | Fold over field types, building adapters and threading the environment -foldFieldAdapters :: t0 -> [Core.FieldType] -> Environment.EncodeEnvironment -> Either Errors.Error ( - [(Core.Name, (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error))], - Environment.EncodeEnvironment) -foldFieldAdapters cx fieldTypes env0 = - Lists.foldl (\acc -> \ft -> Eithers.bind acc (\accPair -> - let soFar = Pairs.first accPair - env1 = Pairs.second accPair - fname = Core.fieldTypeName ft - ftype = Core.fieldTypeType ft - in (Eithers.bind (encodeTypeInner cx Nothing ftype env1) (\adEnv -> - let ad = Pairs.first adEnv - env2 = Pairs.second adEnv - in (Right (Lists.concat2 soFar [ - (fname, ad)], env2)))))) (Right ([], env0)) fieldTypes - --- | Convert Hydra annotations to Avro annotation map -hydraAnnotationsToAvro :: M.Map Core.Name Core.Term -> M.Map String Model.Value -hydraAnnotationsToAvro anns = - Maps.fromList (Lists.map (\entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Core.unName k, (termToJsonValue v))) (Maps.toList anns)) - --- | Encode a single type without a type map (for simple/anonymous types) -hydraAvroAdapter :: t0 -> M.Map Core.Name Core.Type -> Core.Type -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error) -hydraAvroAdapter cx typeMap typ = - Eithers.map (\adEnv -> Pairs.first adEnv) (encodeTypeInner cx Nothing typ (emptyEncodeEnvironment typeMap)) - --- | Convert a Hydra Name to an Avro qualified name (local name, optional namespace) -hydraNameToAvroName :: Core.Name -> (String, (Maybe String)) -hydraNameToAvroName name_ = (localName name_, (nameNamespace name_)) - --- | Create an adapter for integer types -integerAdapter :: t0 -> t1 -> Core.IntegerType -> Either t2 (Coders.Adapter t1 Schema.Schema Core.Term Model.Value Errors.Error) -integerAdapter cx typ it = - - let simple = - \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = typ, - Coders.adapterTarget = target, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encode, - Coders.coderDecode = decode}}) - in case it of - Core.IntegerTypeInt32 -> simple (Schema.SchemaPrimitive Schema.PrimitiveInt) False (\t -> Eithers.map (\i -> Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint i))) (ExtractCore.int32 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of - Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 (Literals.bigintToInt32 (Literals.decimalToBigint v1)))))) - Core.IntegerTypeInt64 -> simple (Schema.SchemaPrimitive Schema.PrimitiveLong) False (\t -> Eithers.map (\i -> Model.ValueNumber (Literals.bigintToDecimal (Literals.int64ToBigint i))) (ExtractCore.int64 (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of - Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 (Literals.bigintToInt64 (Literals.decimalToBigint v1)))))) - _ -> simple (Schema.SchemaPrimitive Schema.PrimitiveLong) True (\t -> case t of - Core.TermLiteral v0 -> case v0 of - Core.LiteralInteger v1 -> Right (Model.ValueNumber (integerValueToDouble v1))) (\j -> case j of - Model.ValueNumber v0 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 (Literals.bigintToInt64 (Literals.decimalToBigint v0)))))) - --- | Convert any integer value to a JSON decimal number -integerValueToDouble :: Core.IntegerValue -> Sci.Scientific -integerValueToDouble iv = - case iv of - Core.IntegerValueBigint v0 -> Literals.bigintToDecimal v0 - Core.IntegerValueInt8 v0 -> Literals.bigintToDecimal (Literals.int8ToBigint v0) - Core.IntegerValueInt16 v0 -> Literals.bigintToDecimal (Literals.int16ToBigint v0) - Core.IntegerValueInt32 v0 -> Literals.bigintToDecimal (Literals.int32ToBigint v0) - Core.IntegerValueInt64 v0 -> Literals.bigintToDecimal (Literals.int64ToBigint v0) - Core.IntegerValueUint8 v0 -> Literals.bigintToDecimal (Literals.uint8ToBigint v0) - Core.IntegerValueUint16 v0 -> Literals.bigintToDecimal (Literals.uint16ToBigint v0) - Core.IntegerValueUint32 v0 -> Literals.bigintToDecimal (Literals.uint32ToBigint v0) - Core.IntegerValueUint64 v0 -> Literals.bigintToDecimal (Literals.uint64ToBigint v0) - --- | Create an adapter for literal types -literalAdapter :: t0 -> t1 -> Core.LiteralType -> Either t2 (Coders.Adapter t1 Schema.Schema Core.Term Model.Value Errors.Error) -literalAdapter cx typ lt = - - let simple = - \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = typ, - Coders.adapterTarget = target, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encode, - Coders.coderDecode = decode}}) - in case lt of - Core.LiteralTypeBoolean -> simple (Schema.SchemaPrimitive Schema.PrimitiveBoolean) False (\t -> case t of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right (Model.ValueBoolean v2)) (\j -> case j of - Model.ValueBoolean v1 -> Right (Core.TermLiteral (Core.LiteralBoolean v1))) - Core.LiteralTypeString -> simple (Schema.SchemaPrimitive Schema.PrimitiveString) False (\t -> case t of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right (Model.ValueString v2)) (\j -> case j of - Model.ValueString v1 -> Right (Core.TermLiteral (Core.LiteralString v1))) - Core.LiteralTypeBinary -> simple (Schema.SchemaPrimitive Schema.PrimitiveBytes) False (\t -> case t of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBinary v2 -> Right (Model.ValueString (Literals.binaryToBase64 v2))) (\j -> case j of - Model.ValueString v1 -> Right (Core.TermLiteral (Core.LiteralBinary (Literals.base64ToBinary v1)))) - Core.LiteralTypeInteger v0 -> integerAdapter cx typ v0 - Core.LiteralTypeFloat v0 -> floatAdapter cx typ v0 - --- | Extract the local part of a qualified name -localName :: Core.Name -> String -localName name_ = - - let s = Core.unName name_ - parts = Strings.splitOn "." s - in (Optionals.withDefault s (Lists.last parts)) - --- | Extract the namespace from a qualified name, if any -nameNamespace :: Core.Name -> Maybe String -nameNamespace name_ = - - let s = Core.unName name_ - parts = Strings.splitOn "." s - in (Logic.ifElse (Equality.equal (Lists.length parts) 1) Nothing (Optionals.map (\ps -> Strings.join "." ps) (Lists.init parts))) - --- | Build a named type adapter (shared between record and union-as-record) -namedTypeAdapter :: t0 -> Core.Type -> Maybe Core.Name -> M.Map Core.Name Core.Term -> [Core.FieldType] -> Environment.EncodeEnvironment -> ([Schema.Field] -> Schema.NamedType) -> (t0 -> Core.Name -> [(Core.Name, (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error))] -> ((Core.Term -> Either Errors.Error Model.Value), (Model.Value -> Either Errors.Error Core.Term))) -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error, Environment.EncodeEnvironment) -namedTypeAdapter cx typ mName annotations fieldTypes env0 mkNamedType mkCoder = - - let typeName = Optionals.withDefault (typeToName typ) mName - in (Optionals.match (Maps.lookup typeName (Environment.encodeEnvironmentEmitted env0)) (Eithers.bind (foldFieldAdapters cx fieldTypes env0) (\faResult -> - let fieldAdapters = Pairs.first faResult - env1 = Pairs.second faResult - avroFields = Lists.map buildAvroField fieldAdapters - avroAnnotations = hydraAnnotationsToAvro annotations - avroSchema = - Schema.SchemaNamed (Schema.Named { - Schema.namedName = (localName typeName), - Schema.namedNamespace = (nameNamespace typeName), - Schema.namedAliases = Nothing, - Schema.namedDoc = Nothing, - Schema.namedType = (mkNamedType avroFields), - Schema.namedAnnotations = avroAnnotations}) - lossy = Lists.foldl (\b -> \fa -> Logic.or b (Coders.adapterIsLossy (Pairs.second fa))) False fieldAdapters - coderPair = mkCoder cx typeName fieldAdapters - encodeFn = Pairs.first coderPair - decodeFn = Pairs.second coderPair - adapter_ = - Coders.Adapter { - Coders.adapterIsLossy = lossy, - Coders.adapterSource = typ, - Coders.adapterTarget = avroSchema, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = encodeFn, - Coders.coderDecode = decodeFn}} - env2 = - Environment.EncodeEnvironment { - Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env1), - Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env1))} - in (Right (adapter_, env2)))) (\existingAd -> Right (existingAd, env0))) - --- | Build a record term coder from field adapters -recordTermCoder :: t0 -> Core.Name -> [(Core.Name, (Coders.Adapter t1 t2 Core.Term Model.Value Errors.Error))] -> ((Core.Term -> Either Errors.Error Model.Value), (Model.Value -> Either Errors.Error Core.Term)) -recordTermCoder cx typeName fieldAdapters = - - let encode = - \term -> case term of - Core.TermRecord v0 -> - let fields = Core.recordFields v0 - fieldMap = Maps.fromList (Lists.map (\f -> (Core.fieldName f, (Core.fieldTerm f))) fields) - encodeField = - \nameAd -> - let fname = Pairs.first nameAd - ad = Pairs.second nameAd - fTerm = Optionals.withDefault Core.TermUnit (Maps.lookup fname fieldMap) - in (Eithers.map (\jv -> (localName fname, jv)) (Coders.coderEncode (Coders.adapterCoder ad) fTerm)) - in (Eithers.map (\pairs -> Model.ValueObject pairs) (Eithers.mapList encodeField fieldAdapters)) - _ -> err cx "expected record term" - decode = - \json -> case json of - Model.ValueObject v0 -> - let mm = Maps.fromList v0 - decodeField = - \nameAd -> - let fname = Pairs.first nameAd - ad = Pairs.second nameAd - jv = Optionals.withDefault Model.ValueNull (Maps.lookup (localName fname) mm) - in (Eithers.map (\t -> Core.Field { - Core.fieldName = fname, - Core.fieldTerm = t}) (Coders.coderDecode (Coders.adapterCoder ad) jv)) - in (Eithers.map (\fields -> Core.TermRecord (Core.Record { - Core.recordTypeName = typeName, - Core.recordFields = fields})) (Eithers.mapList decodeField fieldAdapters)) - _ -> err cx "expected JSON object" - in (encode, decode) - --- | Convert a Hydra term to a JSON value (for annotation values) -termToJsonValue :: Core.Term -> Model.Value -termToJsonValue term = - case term of - Core.TermLiteral v0 -> case v0 of - Core.LiteralString v1 -> Model.ValueString v1 - Core.LiteralBoolean v1 -> Model.ValueBoolean v1 - Core.LiteralInteger v1 -> Model.ValueNumber (integerValueToDouble v1) - Core.LiteralFloat v1 -> Model.ValueNumber (floatValueToDouble v1) - Core.LiteralBinary v1 -> Model.ValueString (Literals.binaryToBase64 v1) - Core.TermList v0 -> Model.ValueArray (Lists.map termToJsonValue v0) - Core.TermMap v0 -> Model.ValueObject (Lists.map (\entry -> - let k = Pairs.first entry - v = Pairs.second entry - in ( - case k of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> v2 - _ -> "" - _ -> "", - (termToJsonValue v))) (Maps.toList v0)) - Core.TermRecord v0 -> Logic.ifElse (Lists.isEmpty (Core.recordFields v0)) Model.ValueNull (Model.ValueString "") - _ -> Model.ValueString "" - --- | Generate a default name for an anonymous type -typeToName :: Core.Type -> Core.Name -typeToName t = - case (Strip.deannotateType t) of - Core.TypeRecord _ -> Core.Name "Record" - Core.TypeUnion _ -> Core.Name "Union" - _ -> Core.Name "Unknown" - --- | Adapter for general unions (encoded as records with optional fields) -unionAsRecordAdapter :: t0 -> Core.Type -> Maybe Core.Name -> M.Map Core.Name Core.Term -> [Core.FieldType] -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error, Environment.EncodeEnvironment) -unionAsRecordAdapter cx typ mName annotations fieldTypes env0 = - Eithers.bind (foldFieldAdapters cx fieldTypes env0) (\faResult -> - let fieldAdapters = Pairs.first faResult - env1 = Pairs.second faResult - avroFields = - Lists.map (\nameAd -> - let fname = Pairs.first nameAd - ad = Pairs.second nameAd - in Schema.Field { - Schema.fieldName = (localName fname), - Schema.fieldDoc = Nothing, - Schema.fieldType = (Schema.SchemaUnion (Schema.Union [ - Schema.SchemaPrimitive Schema.PrimitiveNull, - (Coders.adapterTarget ad)])), - Schema.fieldDefault = (Just Model.ValueNull), - Schema.fieldOrder = Nothing, - Schema.fieldAliases = Nothing, - Schema.fieldAnnotations = Maps.empty}) fieldAdapters - typeName = Optionals.withDefault (typeToName typ) mName - avroAnnotations = hydraAnnotationsToAvro annotations - avroSchema = - Schema.SchemaNamed (Schema.Named { - Schema.namedName = (localName typeName), - Schema.namedNamespace = (nameNamespace typeName), - Schema.namedAliases = Nothing, - Schema.namedDoc = Nothing, - Schema.namedType = (Schema.NamedTypeRecord (Schema.Record { - Schema.recordFields = avroFields})), - Schema.namedAnnotations = avroAnnotations}) - adapter_ = - Coders.Adapter { - Coders.adapterIsLossy = True, - Coders.adapterSource = typ, - Coders.adapterTarget = avroSchema, - Coders.adapterCoder = Coders.Coder { - Coders.coderEncode = (\t -> case t of - Core.TermInject v0 -> - let activeName = Core.fieldName (Core.injectionField v0) - activeValue = Core.fieldTerm (Core.injectionField v0) - encodePair = - \nameAd -> - let fname = Pairs.first nameAd - ad = Pairs.second nameAd - in (Logic.ifElse (Equality.equal (Core.unName fname) (Core.unName activeName)) (Eithers.map (\jv -> (localName fname, jv)) (Coders.coderEncode (Coders.adapterCoder ad) activeValue)) (Right (localName fname, Model.ValueNull))) - in (Eithers.map (\pairs -> Model.ValueObject pairs) (Eithers.mapList encodePair fieldAdapters)) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected union term"))), - Coders.coderDecode = (\j -> case j of - Model.ValueObject v0 -> - let mm = Maps.fromList v0 - findActive = - \remaining -> Optionals.match (Lists.uncons remaining) (Left (Errors.ErrorOther (Errors.OtherError "no non-null field in union record"))) (\p -> - let head_ = Pairs.first p - rest_ = Pairs.second p - fname = Pairs.first head_ - ad = Pairs.second head_ - mjv = Maps.lookup (localName fname) mm - in (Optionals.match mjv (findActive rest_) (\jv -> case jv of - Model.ValueNull -> findActive rest_ - _ -> Eithers.map (\t -> Core.TermInject (Core.Injection { - Core.injectionTypeName = typeName, - Core.injectionField = Core.Field { - Core.fieldName = fname, - Core.fieldTerm = t}})) (Coders.coderDecode (Coders.adapterCoder ad) jv)))) - in (findActive fieldAdapters) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected JSON object for union-as-record")))}} - env2 = - Environment.EncodeEnvironment { - Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env1), - Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env1))} - in (Right (adapter_, env2))) diff --git a/src/main/haskell/Hydra/Avro/Environment.hs b/src/main/haskell/Hydra/Avro/Environment.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Environment.hs +++ /dev/null @@ -1,90 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type definitions for the Avro code generation environment - -module Hydra.Avro.Environment where - -import qualified Hydra.Avro.Schema as Schema -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Environment for Avro-to-Hydra code generation -data AvroEnvironment = - AvroEnvironment { - -- | Named adapters for previously processed schemas - avroEnvironmentNamedAdapters :: (M.Map AvroQualifiedName (Coders.Adapter Schema.Schema Core.Type Model.Value Core.Term Errors.Error)), - -- | The current Avro namespace - avroEnvironmentNamespace :: (Maybe String), - -- | Generated Hydra elements - avroEnvironmentElements :: (M.Map Core.Name Core.Binding)} - -_AvroEnvironment = Core.Name "hydra.avro.environment.AvroEnvironment" - -_AvroEnvironment_namedAdapters = Core.Name "namedAdapters" - -_AvroEnvironment_namespace = Core.Name "namespace" - -_AvroEnvironment_elements = Core.Name "elements" - --- | An Avro foreign key annotation linking a field to another type -data AvroForeignKey = - AvroForeignKey { - -- | The Hydra type name referenced by this foreign key - avroForeignKeyTypeName :: Core.Name, - -- | A function which constructs element names from string values - avroForeignKeyConstructor :: (String -> Core.Name)} - -_AvroForeignKey = Core.Name "hydra.avro.environment.AvroForeignKey" - -_AvroForeignKey_typeName = Core.Name "typeName" - -_AvroForeignKey_constructor = Core.Name "constructor" - --- | An Avro primary key annotation identifying the element name field -data AvroPrimaryKey = - AvroPrimaryKey { - -- | The name of the primary key field - avroPrimaryKeyFieldName :: Core.Name, - -- | A function which constructs element names from string values - avroPrimaryKeyConstructor :: (String -> Core.Name)} - -_AvroPrimaryKey = Core.Name "hydra.avro.environment.AvroPrimaryKey" - -_AvroPrimaryKey_fieldName = Core.Name "fieldName" - -_AvroPrimaryKey_constructor = Core.Name "constructor" - --- | An Avro qualified name with optional namespace -data AvroQualifiedName = - AvroQualifiedName { - -- | The optional namespace - avroQualifiedNameNamespace :: (Maybe String), - -- | The local name - avroQualifiedNameName :: String} - deriving (Eq, Ord, Read, Show) - -_AvroQualifiedName = Core.Name "hydra.avro.environment.AvroQualifiedName" - -_AvroQualifiedName_namespace = Core.Name "namespace" - -_AvroQualifiedName_name = Core.Name "name" - --- | Environment for Hydra-to-Avro encoding, tracking which named types have been emitted -data EncodeEnvironment = - EncodeEnvironment { - -- | All named types available for reference - encodeEnvironmentTypeMap :: (M.Map Core.Name Core.Type), - -- | Adapters for types that have already been fully emitted (emit references for these) - encodeEnvironmentEmitted :: (M.Map Core.Name (Coders.Adapter Core.Type Schema.Schema Core.Term Model.Value Errors.Error))} - -_EncodeEnvironment = Core.Name "hydra.avro.environment.EncodeEnvironment" - -_EncodeEnvironment_typeMap = Core.Name "typeMap" - -_EncodeEnvironment_emitted = Core.Name "emitted" diff --git a/src/main/haskell/Hydra/Avro/Language.hs b/src/main/haskell/Hydra/Avro/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Language.hs +++ /dev/null @@ -1,108 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for Apache Avro - -module Hydra.Avro.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Language constraints for Apache Avro -avroLanguage :: Coders.Language -avroLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.avro"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "avsc")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt32, - Core.IntegerTypeInt64] - termVariants = - Sets.fromList [ - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantRecord] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantWrap, - Variants.TypeVariantOptional, - Variants.TypeVariantRecord] - typePredicate = - \typ -> case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> case (Strip.deannotateType v0) of - Core.TypeOptional _ -> False - _ -> True - _ -> True diff --git a/src/main/haskell/Hydra/Avro/Schema.hs b/src/main/haskell/Hydra/Avro/Schema.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Schema.hs +++ /dev/null @@ -1,236 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for Avro schemas. Based on the Avro 1.11.1 specification: --- | https://avro.apache.org/docs/1.11.1/specification - -module Hydra.Avro.Schema where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | An Avro array schema -data Array = - Array { - arrayItems :: Schema} - deriving (Eq, Ord, Read, Show) - -_Array = Core.Name "hydra.avro.schema.Array" - -_Array_items = Core.Name "items" - --- | An Avro enum schema -data Enum = - Enum { - -- | a JSON array, listing symbols, as JSON strings. All symbols in an enum must be unique; duplicates are prohibited. Every symbol must match the regular expression [A-Za-z_][A-Za-z0-9_]* (the same requirement as for names) - enumSymbols :: [String], - -- | A default value for this enumeration, used during resolution when the reader encounters a symbol from the writer that isn't defined in the reader's schema. The value provided here must be a JSON string that's a member of the symbols array - enumDefault :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Enum = Core.Name "hydra.avro.schema.Enum" - -_Enum_symbols = Core.Name "symbols" - -_Enum_default = Core.Name "default" - --- | An Avro record field -data Field = - Field { - -- | a JSON string providing the name of the field - fieldName :: String, - -- | a JSON string describing this field for users - fieldDoc :: (Maybe String), - -- | a schema - fieldType :: Schema, - -- | default value for this field, only used when reading instances that lack the field for schema evolution purposes - fieldDefault :: (Maybe Model.Value), - -- | specifies how this field impacts sort ordering of this record - fieldOrder :: (Maybe Order), - -- | a JSON array of strings, providing alternate names for this field - fieldAliases :: (Maybe [String]), - -- | Any additional key/value pairs attached to the field - fieldAnnotations :: (M.Map String Model.Value)} - deriving (Eq, Ord, Read, Show) - -_Field = Core.Name "hydra.avro.schema.Field" - -_Field_name = Core.Name "name" - -_Field_doc = Core.Name "doc" - -_Field_type = Core.Name "type" - -_Field_default = Core.Name "default" - -_Field_order = Core.Name "order" - -_Field_aliases = Core.Name "aliases" - -_Field_annotations = Core.Name "annotations" - --- | An Avro fixed-size binary schema -data Fixed = - Fixed { - -- | an integer, specifying the number of bytes per value - fixedSize :: Int} - deriving (Eq, Ord, Read, Show) - -_Fixed = Core.Name "hydra.avro.schema.Fixed" - -_Fixed_size = Core.Name "size" - --- | An Avro map schema -data Map = - Map { - mapValues :: Schema} - deriving (Eq, Ord, Read, Show) - -_Map = Core.Name "hydra.avro.schema.Map" - -_Map_values = Core.Name "values" - --- | An Avro named schema: enum, fixed, or record -data Named = - Named { - -- | a string naming this schema - namedName :: String, - -- | a string that qualifies the name - namedNamespace :: (Maybe String), - -- | a JSON array of strings, providing alternate names for this schema - namedAliases :: (Maybe [String]), - -- | a JSON string providing documentation to the user of this schema - namedDoc :: (Maybe String), - namedType :: NamedType, - -- | Any additional key/value pairs attached to the type - namedAnnotations :: (M.Map String Model.Value)} - deriving (Eq, Ord, Read, Show) - -_Named = Core.Name "hydra.avro.schema.Named" - -_Named_name = Core.Name "name" - -_Named_namespace = Core.Name "namespace" - -_Named_aliases = Core.Name "aliases" - -_Named_doc = Core.Name "doc" - -_Named_type = Core.Name "type" - -_Named_annotations = Core.Name "annotations" - --- | The type-specific content of an Avro named schema -data NamedType = - NamedTypeEnum Enum | - NamedTypeFixed Fixed | - NamedTypeRecord Record - deriving (Eq, Ord, Read, Show) - -_NamedType = Core.Name "hydra.avro.schema.NamedType" - -_NamedType_enum = Core.Name "enum" - -_NamedType_fixed = Core.Name "fixed" - -_NamedType_record = Core.Name "record" - --- | Specifies how a field impacts sort ordering of its enclosing record -data Order = - OrderAscending | - OrderDescending | - OrderIgnore - deriving (Eq, Ord, Read, Show) - -_Order = Core.Name "hydra.avro.schema.Order" - -_Order_ascending = Core.Name "ascending" - -_Order_descending = Core.Name "descending" - -_Order_ignore = Core.Name "ignore" - --- | An Avro primitive type -data Primitive = - -- | no value - PrimitiveNull | - -- | A binary value - PrimitiveBoolean | - -- | 32-bit signed integer - PrimitiveInt | - -- | 64-bit signed integer - PrimitiveLong | - -- | single precision (32-bit) IEEE 754 floating-point number - PrimitiveFloat | - -- | double precision (64-bit) IEEE 754 floating-point number - PrimitiveDouble | - -- | sequence of 8-bit unsigned bytes - PrimitiveBytes | - -- | unicode character sequence - PrimitiveString - deriving (Eq, Ord, Read, Show) - -_Primitive = Core.Name "hydra.avro.schema.Primitive" - -_Primitive_null = Core.Name "null" - -_Primitive_boolean = Core.Name "boolean" - -_Primitive_int = Core.Name "int" - -_Primitive_long = Core.Name "long" - -_Primitive_float = Core.Name "float" - -_Primitive_double = Core.Name "double" - -_Primitive_bytes = Core.Name "bytes" - -_Primitive_string = Core.Name "string" - --- | An Avro record schema -data Record = - Record { - -- | a JSON array, listing fields - recordFields :: [Field]} - deriving (Eq, Ord, Read, Show) - -_Record = Core.Name "hydra.avro.schema.Record" - -_Record_fields = Core.Name "fields" - --- | An Avro schema, in any of its forms -data Schema = - SchemaArray Array | - SchemaMap Map | - SchemaNamed Named | - SchemaPrimitive Primitive | - -- | A reference by name to a previously defined type - SchemaReference String | - SchemaUnion Union - deriving (Eq, Ord, Read, Show) - -_Schema = Core.Name "hydra.avro.schema.Schema" - -_Schema_array = Core.Name "array" - -_Schema_map = Core.Name "map" - -_Schema_named = Core.Name "named" - -_Schema_primitive = Core.Name "primitive" - -_Schema_reference = Core.Name "reference" - -_Schema_union = Core.Name "union" - --- | An Avro union schema: a list of alternative schemas -newtype Union = - Union { - unUnion :: [Schema]} - deriving (Eq, Ord, Read, Show) - -_Union = Core.Name "hydra.avro.schema.Union" diff --git a/src/main/haskell/Hydra/Avro/SchemaJson.hs b/src/main/haskell/Hydra/Avro/SchemaJson.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/SchemaJson.hs +++ /dev/null @@ -1,482 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON serialization and deserialization for Avro schemas - -module Hydra.Avro.SchemaJson where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Avro.Schema as Schema -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.Json.Parser as Parser -import qualified Hydra.Json.Writer as Writer -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | The JSON attribute name for the list of alternate names of a named type or field -avroAliases :: String -avroAliases = "aliases" - --- | The JSON type-name value identifying an Avro array schema -avroArray :: String -avroArray = "array" - --- | The JSON value identifying ascending field order -avroAscending :: String -avroAscending = "ascending" - --- | The JSON type-name value identifying the Avro boolean primitive -avroBoolean :: String -avroBoolean = "boolean" - --- | The JSON type-name value identifying the Avro bytes primitive -avroBytes :: String -avroBytes = "bytes" - --- | The JSON attribute name for a field's or enum's default value -avroDefault :: String -avroDefault = "default" - --- | The JSON value identifying descending field order -avroDescending :: String -avroDescending = "descending" - --- | The JSON attribute name for a named type's or field's documentation string -avroDoc :: String -avroDoc = "doc" - --- | The JSON type-name value identifying the Avro double primitive -avroDouble :: String -avroDouble = "double" - --- | The JSON type-name value identifying an Avro enum schema -avroEnum :: String -avroEnum = "enum" - --- | The JSON attribute name for a record's list of fields -avroFields :: String -avroFields = "fields" - --- | The JSON type-name value identifying an Avro fixed schema -avroFixed :: String -avroFixed = "fixed" - --- | The JSON type-name value identifying the Avro float primitive -avroFloat :: String -avroFloat = "float" - --- | The JSON value identifying ignored field order -avroIgnore :: String -avroIgnore = "ignore" - --- | The JSON type-name value identifying the Avro int primitive -avroInt :: String -avroInt = "int" - --- | The JSON attribute name for an array schema's item type -avroItems :: String -avroItems = "items" - --- | The JSON type-name value identifying the Avro long primitive -avroLong :: String -avroLong = "long" - --- | The JSON type-name value identifying an Avro map schema -avroMap :: String -avroMap = "map" - --- | The JSON attribute name for a named type's or field's name -avroName :: String -avroName = "name" - --- | The JSON attribute name for a named type's namespace -avroNamespace :: String -avroNamespace = "namespace" - --- | The JSON type-name value identifying the Avro null primitive -avroNull :: String -avroNull = "null" - --- | The JSON attribute name for a field's sort order -avroOrder :: String -avroOrder = "order" - --- | The JSON type-name value identifying an Avro record schema -avroRecord :: String -avroRecord = "record" - --- | Create a coder between Avro schemas and JSON values -avroSchemaJsonCoder :: t0 -> Coders.Coder Schema.Schema Model.Value Errors.Error -avroSchemaJsonCoder cx = - Coders.Coder { - Coders.coderEncode = (\schema -> Right (encodeSchema schema)), - Coders.coderDecode = (\json -> decodeSchema cx json)} - --- | Create a coder between Avro schemas and JSON strings -avroSchemaStringCoder :: t0 -> Coders.Coder Schema.Schema String Errors.Error -avroSchemaStringCoder cx = - Coders.Coder { - Coders.coderEncode = (\schema -> Right (showJsonValue (encodeSchema schema))), - Coders.coderDecode = (\s -> Eithers.bind (Eithers.either (\e -> err cx e) (\v -> Right v) (stringToJsonValue s)) (\json -> decodeSchema cx json))} - --- | The JSON attribute name for a fixed schema's byte size -avroSize :: String -avroSize = "size" - --- | The JSON type-name value identifying the Avro string primitive -avroString :: String -avroString = "string" - --- | The JSON attribute name for an enum schema's list of symbols -avroSymbols :: String -avroSymbols = "symbols" - --- | The JSON attribute name for a schema's type name -avroType :: String -avroType = "type" - --- | The JSON attribute name for a map schema's value type -avroValues :: String -avroValues = "values" - --- | Decode aliases from a JSON object map -decodeAliases :: t0 -> M.Map String Model.Value -> Either t1 (Maybe [String]) -decodeAliases cx m = - Eithers.bind (optArrayE cx avroAliases m) (\mArr -> Optionals.match mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.given strs) (Eithers.mapList (expectStringE cx) arr))) - --- | Decode an Avro array schema from a JSON object map -decodeArraySchema :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.Schema -decodeArraySchema cx m = - Eithers.bind (requireE cx avroItems m) (\items -> Eithers.map (\s -> Schema.SchemaArray (Schema.Array { - Schema.arrayItems = s})) (decodeSchema cx items)) - --- | Decode an Avro enum type from a JSON object map -decodeEnum :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.NamedType -decodeEnum cx m = - Eithers.bind (requireArrayE cx avroSymbols m) (\syms -> Eithers.bind (Eithers.mapList (expectStringE cx) syms) (\symbols -> Eithers.bind (optStringE cx avroDefault m) (\defVal -> Right (Schema.NamedTypeEnum (Schema.Enum { - Schema.enumSymbols = symbols, - Schema.enumDefault = defVal}))))) - --- | Decode an Avro field from a JSON object map -decodeField :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.Field -decodeField cx m = - Eithers.bind (requireStringE cx avroName m) (\name -> Eithers.bind (optStringE cx avroDoc m) (\fdoc -> Eithers.bind (requireE cx avroType m) (\typeJson -> Eithers.bind (decodeSchema cx typeJson) (\fieldType -> Eithers.bind (Eithers.bind (optStringE cx avroOrder m) (\mOrd -> Eithers.mapOptional (decodeOrder cx) mOrd)) (\order -> Eithers.bind (decodeAliases cx m) (\aliases -> Right (Schema.Field { - Schema.fieldName = name, - Schema.fieldDoc = fdoc, - Schema.fieldType = fieldType, - Schema.fieldDefault = (optE avroDefault m), - Schema.fieldOrder = order, - Schema.fieldAliases = aliases, - Schema.fieldAnnotations = (getAnnotations m)}))))))) - --- | Decode an Avro fixed type from a JSON object map -decodeFixed :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.NamedType -decodeFixed cx m = - Eithers.bind (requireNumberE cx avroSize m) (\n -> - let size = Literals.bigintToInt32 (Literals.decimalToBigint n) - in (Right (Schema.NamedTypeFixed (Schema.Fixed { - Schema.fixedSize = size})))) - --- | Decode an Avro map schema from a JSON object map -decodeMapSchema :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.Schema -decodeMapSchema cx m = - Eithers.bind (requireE cx avroValues m) (\values -> Eithers.map (\s -> Schema.SchemaMap (Schema.Map { - Schema.mapValues = s})) (decodeSchema cx values)) - --- | Decode a named Avro schema from a JSON object map and a decoded named type result -decodeNamedSchema :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.NamedType -> Either Errors.Error Schema.Schema -decodeNamedSchema cx m namedTypeResult = - Eithers.bind (requireStringE cx avroName m) (\name -> Eithers.bind (optStringE cx avroNamespace m) (\ns -> Eithers.bind (optStringE cx avroDoc m) (\sdoc -> Eithers.bind (decodeAliases cx m) (\aliases -> Eithers.bind namedTypeResult (\namedType -> Right (Schema.SchemaNamed (Schema.Named { - Schema.namedName = name, - Schema.namedNamespace = ns, - Schema.namedAliases = aliases, - Schema.namedDoc = sdoc, - Schema.namedType = namedType, - Schema.namedAnnotations = (getAnnotations m)}))))))) - --- | Decode an Avro schema from a JSON object given the type name -decodeObjectSchema :: t0 -> M.Map String Model.Value -> String -> Either Errors.Error Schema.Schema -decodeObjectSchema cx m typeName = - Logic.ifElse (Equality.equal typeName "array") (decodeArraySchema cx m) (Logic.ifElse (Equality.equal typeName "map") (decodeMapSchema cx m) (Logic.ifElse (Equality.equal typeName "record") (decodeNamedSchema cx m (decodeRecord cx m)) (Logic.ifElse (Equality.equal typeName "enum") (decodeNamedSchema cx m (decodeEnum cx m)) (Logic.ifElse (Equality.equal typeName "fixed") (decodeNamedSchema cx m (decodeFixed cx m)) (Optionals.match (decodePrimitiveName typeName) (err cx (Strings.concat [ - "unknown type: ", - typeName])) (\p -> Right (Schema.SchemaPrimitive p))))))) - --- | Decode an Avro field ordering from a string -decodeOrder :: t0 -> String -> Either Errors.Error Schema.Order -decodeOrder cx o = - Logic.ifElse (Equality.equal o "ascending") (Right Schema.OrderAscending) (Logic.ifElse (Equality.equal o "descending") (Right Schema.OrderDescending) (Logic.ifElse (Equality.equal o "ignore") (Right Schema.OrderIgnore) (err cx (Strings.concat [ - "unknown order: ", - o])))) - --- | Decode a primitive type name string to a Primitive, or Nothing if not a primitive -decodePrimitiveName :: String -> Maybe Schema.Primitive -decodePrimitiveName s = - Logic.ifElse (Equality.equal s "null") (Just Schema.PrimitiveNull) (Logic.ifElse (Equality.equal s "boolean") (Just Schema.PrimitiveBoolean) (Logic.ifElse (Equality.equal s "int") (Just Schema.PrimitiveInt) (Logic.ifElse (Equality.equal s "long") (Just Schema.PrimitiveLong) (Logic.ifElse (Equality.equal s "float") (Just Schema.PrimitiveFloat) (Logic.ifElse (Equality.equal s "double") (Just Schema.PrimitiveDouble) (Logic.ifElse (Equality.equal s "bytes") (Just Schema.PrimitiveBytes) (Logic.ifElse (Equality.equal s "string") (Just Schema.PrimitiveString) Nothing))))))) - --- | Decode an Avro record type from a JSON object map -decodeRecord :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.NamedType -decodeRecord cx m = - Eithers.bind (requireArrayE cx avroFields m) (\fieldJsons -> Eithers.bind (Eithers.mapList (\fj -> Eithers.bind (expectObjectE cx fj) (\fm -> decodeField cx fm)) fieldJsons) (\fields -> Right (Schema.NamedTypeRecord (Schema.Record { - Schema.recordFields = fields})))) - --- | Decode an Avro schema from a JSON value -decodeSchema :: t0 -> Model.Value -> Either Errors.Error Schema.Schema -decodeSchema cx v = - case v of - Model.ValueString v0 -> Optionals.match (decodePrimitiveName v0) (Right (Schema.SchemaReference v0)) (\p -> Right (Schema.SchemaPrimitive p)) - Model.ValueArray v0 -> Eithers.map (\decoded -> Schema.SchemaUnion (Schema.Union decoded)) (Eithers.mapList (decodeSchema cx) v0) - Model.ValueObject v0 -> - let m = Maps.fromList v0 - in (Eithers.bind (requireStringE cx avroType m) (\typeName -> decodeObjectSchema cx m typeName)) - _ -> err cx (Strings.concat [ - "unexpected JSON value for schema: ", - (showJsonValue v)]) - --- | Encode annotations as key-value pairs with @ prefix on keys -encodeAnnotations :: M.Map String t0 -> [(String, t0)] -encodeAnnotations m = Lists.map (\entry -> (Strings.concat2 "@" (Pairs.first entry), (Pairs.second entry))) (Maps.toList m) - --- | Encode an Avro array schema to a JSON object -encodeArray :: Schema.Array -> Model.Value -encodeArray arr = - Model.ValueObject [ - ("type", (Model.ValueString "array")), - ("items", (encodeSchema (Schema.arrayItems arr)))] - --- | Encode an Avro enum type as key-value pairs -encodeEnum :: Schema.Enum -> [(String, Model.Value)] -encodeEnum e = - Lists.concat [ - [ - ("type", (Model.ValueString "enum"))], - [ - ("symbols", (Model.ValueArray (Lists.map (\s -> Model.ValueString s) (Schema.enumSymbols e))))], - (Optionals.match (Schema.enumDefault e) [] (\d -> [ - ("default", (Model.ValueString d))]))] - --- | Encode an Avro field to a JSON object -encodeField :: Schema.Field -> Model.Value -encodeField f = - Model.ValueObject (Lists.concat [ - [ - ("name", (Model.ValueString (Schema.fieldName f)))], - [ - ("type", (encodeSchema (Schema.fieldType f)))], - (Optionals.match (Schema.fieldDoc f) [] (\d -> [ - ("doc", (Model.ValueString d))])), - (Optionals.match (Schema.fieldDefault f) [] (\d -> [ - ("default", d)])), - (Optionals.match (Schema.fieldOrder f) [] (\o -> [ - encodeOrder o])), - (Optionals.match (Schema.fieldAliases f) [] (\als -> [ - ("aliases", (Model.ValueArray (Lists.map (\a -> Model.ValueString a) als)))])), - (encodeAnnotations (Schema.fieldAnnotations f))]) - --- | Encode an Avro fixed type as key-value pairs -encodeFixed :: Schema.Fixed -> [(String, Model.Value)] -encodeFixed f = - [ - ("type", (Model.ValueString "fixed")), - ("size", (Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint (Schema.fixedSize f)))))] - --- | Encode an Avro map schema to a JSON object -encodeMap :: Schema.Map -> Model.Value -encodeMap mp = - Model.ValueObject [ - ("type", (Model.ValueString "map")), - ("values", (encodeSchema (Schema.mapValues mp)))] - --- | Encode an Avro named type to a JSON object -encodeNamed :: Schema.Named -> Model.Value -encodeNamed n = - Model.ValueObject (Lists.concat [ - [ - ("name", (Model.ValueString (Schema.namedName n)))], - (Optionals.match (Schema.namedNamespace n) [] (\ns -> [ - ("namespace", (Model.ValueString ns))])), - (Optionals.match (Schema.namedDoc n) [] (\d -> [ - ("doc", (Model.ValueString d))])), - (Optionals.match (Schema.namedAliases n) [] (\als -> [ - ("aliases", (Model.ValueArray (Lists.map (\a -> Model.ValueString a) als)))])), - (encodeNamedType (Schema.namedType n)), - (encodeAnnotations (Schema.namedAnnotations n))]) - --- | Encode the specific variant of a named Avro type -encodeNamedType :: Schema.NamedType -> [(String, Model.Value)] -encodeNamedType nt = - case nt of - Schema.NamedTypeEnum v0 -> encodeEnum v0 - Schema.NamedTypeFixed v0 -> encodeFixed v0 - Schema.NamedTypeRecord v0 -> encodeRecord v0 - --- | Encode an Avro field ordering as a key-value pair -encodeOrder :: Schema.Order -> (String, Model.Value) -encodeOrder o = - ( - "order", - (Model.ValueString (case o of - Schema.OrderAscending -> "ascending" - Schema.OrderDescending -> "descending" - Schema.OrderIgnore -> "ignore"))) - --- | Encode an Avro primitive type as a JSON string -encodePrimitive :: Schema.Primitive -> Model.Value -encodePrimitive p = - Model.ValueString (case p of - Schema.PrimitiveNull -> "null" - Schema.PrimitiveBoolean -> "boolean" - Schema.PrimitiveInt -> "int" - Schema.PrimitiveLong -> "long" - Schema.PrimitiveFloat -> "float" - Schema.PrimitiveDouble -> "double" - Schema.PrimitiveBytes -> "bytes" - Schema.PrimitiveString -> "string") - --- | Encode an Avro record type as key-value pairs -encodeRecord :: Schema.Record -> [(String, Model.Value)] -encodeRecord r = - [ - ("type", (Model.ValueString "record")), - ("fields", (Model.ValueArray (Lists.map encodeField (Schema.recordFields r))))] - --- | Encode an Avro schema to a JSON value -encodeSchema :: Schema.Schema -> Model.Value -encodeSchema schema = - case schema of - Schema.SchemaPrimitive v0 -> encodePrimitive v0 - Schema.SchemaArray v0 -> encodeArray v0 - Schema.SchemaMap v0 -> encodeMap v0 - Schema.SchemaNamed v0 -> encodeNamed v0 - Schema.SchemaReference v0 -> Model.ValueString v0 - Schema.SchemaUnion v0 -> encodeUnion v0 - --- | Encode an Avro union as a JSON array of schemas -encodeUnion :: Schema.Union -> Model.Value -encodeUnion u = Model.ValueArray (Lists.map encodeSchema (Schema.unUnion u)) - --- | Construct an error result with a message in context -err :: t0 -> String -> Either Errors.Error t1 -err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) - --- | Extract a JSON array or return an error -expectArrayE :: t0 -> Model.Value -> Either t1 [Model.Value] -expectArrayE cx value = - case value of - Model.ValueArray v0 -> Right v0 - --- | Extract a JSON number or return an error -expectNumberE :: t0 -> Model.Value -> Either t1 Sci.Scientific -expectNumberE cx value = - case value of - Model.ValueNumber v0 -> Right v0 - --- | Extract a JSON object as a name-keyed map or return an error (field order is dropped) -expectObjectE :: t0 -> Model.Value -> Either t1 (M.Map String Model.Value) -expectObjectE cx value = - case value of - Model.ValueObject v0 -> Right (Maps.fromList v0) - --- | Extract a JSON string or return an error -expectStringE :: t0 -> Model.Value -> Either t1 String -expectStringE cx value = - case value of - Model.ValueString v0 -> Right v0 - --- | Extract annotation entries (keys starting with @) from a JSON object map -getAnnotations :: M.Map String t0 -> M.Map String t0 -getAnnotations m = - Maps.fromList (Optionals.givens (Lists.map (\entry -> - let k = Pairs.first entry - v = Pairs.second entry - in (Logic.ifElse (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 k)) 64) (Optionals.given (Strings.fromList (Lists.drop 1 (Strings.toList k)), v)) Nothing)) (Maps.toList m))) - --- | Look up an optional array attribute in a JSON object map -optArrayE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe [Model.Value])) -optArrayE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\a -> Optionals.given a) (expectArrayE cx v)) - --- | Look up an optional attribute in a JSON object map -optE :: Ord t0 => (t0 -> M.Map t0 t1 -> Maybe t1) -optE k m = Maps.lookup k m - --- | Look up an optional string attribute in a JSON object map -optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe String)) -optStringE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) - --- | Look up a required array attribute in a JSON object map -requireArrayE :: t0 -> String -> M.Map String Model.Value -> Either Errors.Error [Model.Value] -requireArrayE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectArrayE cx v) - --- | Look up a required attribute in a JSON object map -requireE :: t0 -> String -> M.Map String t1 -> Either Errors.Error t1 -requireE cx fname m = - Optionals.match (Maps.lookup fname m) (err cx (Strings.concat [ - "required attribute ", - (Literals.printString fname), - " not found"])) (\v -> Right v) - --- | Look up a required number attribute in a JSON object map -requireNumberE :: t0 -> String -> M.Map String Model.Value -> Either Errors.Error Sci.Scientific -requireNumberE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectNumberE cx v) - --- | Look up a required string attribute in a JSON object map -requireStringE :: t0 -> String -> M.Map String Model.Value -> Either Errors.Error String -requireStringE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectStringE cx v) - --- | Convert a JSON value to its string representation -showJsonValue :: Model.Value -> String -showJsonValue v = Writer.printJson v - --- | Parse a JSON string, returning Either for compatibility -stringToJsonValue :: String -> Either String Model.Value -stringToJsonValue s = - (\x -> case x of - Parsing.ParseResultSuccess v0 -> Right (Parsing.parseSuccessValue v0) - Parsing.ParseResultFailure v0 -> Left (Parsing.parseErrorMessage v0)) (Parser.parseJson s) - --- | Construct an error for unexpected values -unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 -unexpectedE cx expected found = - err cx (Strings.concat [ - "Expected ", - expected, - ", found: ", - found]) diff --git a/src/main/haskell/Hydra/Avro/Testing.hs b/src/main/haskell/Hydra/Avro/Testing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Avro/Testing.hs +++ /dev/null @@ -1,326 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Test case types for the bidirectional Avro coder - -module Hydra.Avro.Testing where - -import qualified Hydra.Avro.Schema as Schema -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A test case for the bidirectional Avro coder -data AvroTestCase = - -- | Type-level forward mapping (Avro Schema -> Hydra Type) - AvroTestCaseTypeLevelForward TypeLevelForwardTestCase | - -- | Type-level reverse mapping (Hydra Type -> Avro Schema) - AvroTestCaseTypeLevelReverse TypeLevelReverseTestCase | - -- | Type-level round-trip starting from Avro (Avro -> Hydra -> Avro) - AvroTestCaseTypeLevelRoundTripAvro TypeLevelRoundTripAvroTestCase | - -- | Type-level round-trip starting from Hydra (Hydra -> Avro -> Hydra) - AvroTestCaseTypeLevelRoundTripHydra TypeLevelRoundTripHydraTestCase | - -- | Term-level forward mapping (JSON -> Hydra Term) - AvroTestCaseTermLevelForward TermLevelForwardTestCase | - -- | Term-level reverse mapping (Hydra Term -> JSON) - AvroTestCaseTermLevelReverse TermLevelReverseTestCase | - -- | Term-level round-trip starting from JSON (JSON -> Term -> JSON) - AvroTestCaseTermLevelRoundTripJson TermLevelRoundTripJsonTestCase | - -- | Term-level round-trip starting from a term (Term -> JSON -> Term) - AvroTestCaseTermLevelRoundTripTerm TermLevelRoundTripTermTestCase | - -- | Union-specific encoding and decoding - AvroTestCaseUnion UnionTestCase | - -- | Name mapping between Hydra and Avro - AvroTestCaseNameMapping NameMappingTestCase | - -- | Lossy conversion with annotation stashing - AvroTestCaseLossiness LossinessTestCase | - -- | Schema serialization to and from JSON - AvroTestCaseSchemaSerialization SchemaSerializationTestCase - deriving (Eq, Ord, Read, Show) - -_AvroTestCase = Core.Name "hydra.avro.testing.AvroTestCase" - -_AvroTestCase_typeLevelForward = Core.Name "typeLevelForward" - -_AvroTestCase_typeLevelReverse = Core.Name "typeLevelReverse" - -_AvroTestCase_typeLevelRoundTripAvro = Core.Name "typeLevelRoundTripAvro" - -_AvroTestCase_typeLevelRoundTripHydra = Core.Name "typeLevelRoundTripHydra" - -_AvroTestCase_termLevelForward = Core.Name "termLevelForward" - -_AvroTestCase_termLevelReverse = Core.Name "termLevelReverse" - -_AvroTestCase_termLevelRoundTripJson = Core.Name "termLevelRoundTripJson" - -_AvroTestCase_termLevelRoundTripTerm = Core.Name "termLevelRoundTripTerm" - -_AvroTestCase_union = Core.Name "union" - -_AvroTestCase_nameMapping = Core.Name "nameMapping" - -_AvroTestCase_lossiness = Core.Name "lossiness" - -_AvroTestCase_schemaSerialization = Core.Name "schemaSerialization" - --- | A test case which verifies that lossy conversions stash original information in annotations -data LossinessTestCase = - LossinessTestCase { - -- | A human-readable description of what this test case covers - lossinessTestCaseDescription :: String, - -- | The original Avro schema containing information that may be lost - lossinessTestCaseOriginalSchema :: Schema.Schema, - -- | The resulting Hydra type, which should carry annotations for any lost information - lossinessTestCaseHydraType :: Core.Type, - -- | The Avro schema recovered from the annotated Hydra type - lossinessTestCaseRecoveredSchema :: Schema.Schema, - -- | Whether the adapter reports this conversion as lossy - lossinessTestCaseIsLossy :: Bool} - deriving (Eq, Ord, Read, Show) - -_LossinessTestCase = Core.Name "hydra.avro.testing.LossinessTestCase" - -_LossinessTestCase_description = Core.Name "description" - -_LossinessTestCase_originalSchema = Core.Name "originalSchema" - -_LossinessTestCase_hydraType = Core.Name "hydraType" - -_LossinessTestCase_recoveredSchema = Core.Name "recoveredSchema" - -_LossinessTestCase_isLossy = Core.Name "isLossy" - --- | A test case for bidirectional name mapping between Hydra and Avro -data NameMappingTestCase = - NameMappingTestCase { - -- | A human-readable description of what this test case covers - nameMappingTestCaseDescription :: String, - -- | The Hydra name - nameMappingTestCaseHydraName :: Core.Name, - -- | The expected Avro qualified name (dotted string) - nameMappingTestCaseAvroName :: String, - -- | The expected Avro namespace, if any - nameMappingTestCaseAvroNamespace :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_NameMappingTestCase = Core.Name "hydra.avro.testing.NameMappingTestCase" - -_NameMappingTestCase_description = Core.Name "description" - -_NameMappingTestCase_hydraName = Core.Name "hydraName" - -_NameMappingTestCase_avroName = Core.Name "avroName" - -_NameMappingTestCase_avroNamespace = Core.Name "avroNamespace" - --- | A test case for Avro schema serialization to and from JSON -data SchemaSerializationTestCase = - SchemaSerializationTestCase { - -- | A human-readable description of what this test case covers - schemaSerializationTestCaseDescription :: String, - -- | The Avro schema - schemaSerializationTestCaseSchema :: Schema.Schema, - -- | The expected JSON representation of the schema - schemaSerializationTestCaseJson :: Model.Value} - deriving (Eq, Ord, Read, Show) - -_SchemaSerializationTestCase = Core.Name "hydra.avro.testing.SchemaSerializationTestCase" - -_SchemaSerializationTestCase_description = Core.Name "description" - -_SchemaSerializationTestCase_schema = Core.Name "schema" - -_SchemaSerializationTestCase_json = Core.Name "json" - --- | A test case which encodes a JSON value as a Hydra term using an Avro schema -data TermLevelForwardTestCase = - TermLevelForwardTestCase { - -- | A human-readable description of what this test case covers - termLevelForwardTestCaseDescription :: String, - -- | The Avro schema describing the JSON value - termLevelForwardTestCaseSchema :: Schema.Schema, - -- | The input JSON value - termLevelForwardTestCaseJson :: Model.Value, - -- | The expected Hydra term - termLevelForwardTestCaseTerm :: Core.Term} - deriving (Eq, Ord, Read, Show) - -_TermLevelForwardTestCase = Core.Name "hydra.avro.testing.TermLevelForwardTestCase" - -_TermLevelForwardTestCase_description = Core.Name "description" - -_TermLevelForwardTestCase_schema = Core.Name "schema" - -_TermLevelForwardTestCase_json = Core.Name "json" - -_TermLevelForwardTestCase_term = Core.Name "term" - --- | A test case which decodes a Hydra term to a JSON value using an Avro schema -data TermLevelReverseTestCase = - TermLevelReverseTestCase { - -- | A human-readable description of what this test case covers - termLevelReverseTestCaseDescription :: String, - -- | The Avro schema describing the expected JSON value - termLevelReverseTestCaseSchema :: Schema.Schema, - -- | The input Hydra term - termLevelReverseTestCaseTerm :: Core.Term, - -- | The expected JSON value - termLevelReverseTestCaseJson :: Model.Value} - deriving (Eq, Ord, Read, Show) - -_TermLevelReverseTestCase = Core.Name "hydra.avro.testing.TermLevelReverseTestCase" - -_TermLevelReverseTestCase_description = Core.Name "description" - -_TermLevelReverseTestCase_schema = Core.Name "schema" - -_TermLevelReverseTestCase_term = Core.Name "term" - -_TermLevelReverseTestCase_json = Core.Name "json" - --- | A test case which encodes a JSON value as a Hydra term and decodes it back, verifying the result -data TermLevelRoundTripJsonTestCase = - TermLevelRoundTripJsonTestCase { - -- | A human-readable description of what this test case covers - termLevelRoundTripJsonTestCaseDescription :: String, - -- | The Avro schema describing the JSON value - termLevelRoundTripJsonTestCaseSchema :: Schema.Schema, - -- | The original JSON value - termLevelRoundTripJsonTestCaseJson :: Model.Value, - -- | The expected JSON value after the round-trip, which may differ from the original due to normalization - termLevelRoundTripJsonTestCaseExpectedJson :: Model.Value} - deriving (Eq, Ord, Read, Show) - -_TermLevelRoundTripJsonTestCase = Core.Name "hydra.avro.testing.TermLevelRoundTripJsonTestCase" - -_TermLevelRoundTripJsonTestCase_description = Core.Name "description" - -_TermLevelRoundTripJsonTestCase_schema = Core.Name "schema" - -_TermLevelRoundTripJsonTestCase_json = Core.Name "json" - -_TermLevelRoundTripJsonTestCase_expectedJson = Core.Name "expectedJson" - --- | A test case which decodes a Hydra term to JSON and encodes it back, verifying the result -data TermLevelRoundTripTermTestCase = - TermLevelRoundTripTermTestCase { - -- | A human-readable description of what this test case covers - termLevelRoundTripTermTestCaseDescription :: String, - -- | The Hydra type of the term - termLevelRoundTripTermTestCaseType :: Core.Type, - -- | The original Hydra term - termLevelRoundTripTermTestCaseTerm :: Core.Term, - -- | The expected Hydra term after the round-trip, which may differ from the original due to normalization - termLevelRoundTripTermTestCaseExpectedTerm :: Core.Term} - deriving (Eq, Ord, Read, Show) - -_TermLevelRoundTripTermTestCase = Core.Name "hydra.avro.testing.TermLevelRoundTripTermTestCase" - -_TermLevelRoundTripTermTestCase_description = Core.Name "description" - -_TermLevelRoundTripTermTestCase_type = Core.Name "type" - -_TermLevelRoundTripTermTestCase_term = Core.Name "term" - -_TermLevelRoundTripTermTestCase_expectedTerm = Core.Name "expectedTerm" - --- | A test case which maps an Avro schema to a Hydra type and compares the result -data TypeLevelForwardTestCase = - TypeLevelForwardTestCase { - -- | A human-readable description of what this test case covers - typeLevelForwardTestCaseDescription :: String, - -- | The input Avro schema - typeLevelForwardTestCaseSchema :: Schema.Schema, - -- | The expected Hydra type - typeLevelForwardTestCaseType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_TypeLevelForwardTestCase = Core.Name "hydra.avro.testing.TypeLevelForwardTestCase" - -_TypeLevelForwardTestCase_description = Core.Name "description" - -_TypeLevelForwardTestCase_schema = Core.Name "schema" - -_TypeLevelForwardTestCase_type = Core.Name "type" - --- | A test case which maps a Hydra type to an Avro schema and compares the result -data TypeLevelReverseTestCase = - TypeLevelReverseTestCase { - -- | A human-readable description of what this test case covers - typeLevelReverseTestCaseDescription :: String, - -- | The input Hydra type - typeLevelReverseTestCaseType :: Core.Type, - -- | The expected Avro schema - typeLevelReverseTestCaseSchema :: Schema.Schema} - deriving (Eq, Ord, Read, Show) - -_TypeLevelReverseTestCase = Core.Name "hydra.avro.testing.TypeLevelReverseTestCase" - -_TypeLevelReverseTestCase_description = Core.Name "description" - -_TypeLevelReverseTestCase_type = Core.Name "type" - -_TypeLevelReverseTestCase_schema = Core.Name "schema" - --- | A test case which maps an Avro schema to a Hydra type and back, verifying the result -data TypeLevelRoundTripAvroTestCase = - TypeLevelRoundTripAvroTestCase { - -- | A human-readable description of what this test case covers - typeLevelRoundTripAvroTestCaseDescription :: String, - -- | The original Avro schema - typeLevelRoundTripAvroTestCaseSchema :: Schema.Schema, - -- | The expected Avro schema after the round-trip, which may differ from the original due to normalization or information loss - typeLevelRoundTripAvroTestCaseExpectedSchema :: Schema.Schema} - deriving (Eq, Ord, Read, Show) - -_TypeLevelRoundTripAvroTestCase = Core.Name "hydra.avro.testing.TypeLevelRoundTripAvroTestCase" - -_TypeLevelRoundTripAvroTestCase_description = Core.Name "description" - -_TypeLevelRoundTripAvroTestCase_schema = Core.Name "schema" - -_TypeLevelRoundTripAvroTestCase_expectedSchema = Core.Name "expectedSchema" - --- | A test case which maps a Hydra type to an Avro schema and back, verifying the result -data TypeLevelRoundTripHydraTestCase = - TypeLevelRoundTripHydraTestCase { - -- | A human-readable description of what this test case covers - typeLevelRoundTripHydraTestCaseDescription :: String, - -- | The original Hydra type - typeLevelRoundTripHydraTestCaseType :: Core.Type, - -- | The expected Hydra type after the round-trip, which may differ from the original due to normalization or information loss - typeLevelRoundTripHydraTestCaseExpectedType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_TypeLevelRoundTripHydraTestCase = Core.Name "hydra.avro.testing.TypeLevelRoundTripHydraTestCase" - -_TypeLevelRoundTripHydraTestCase_description = Core.Name "description" - -_TypeLevelRoundTripHydraTestCase_type = Core.Name "type" - -_TypeLevelRoundTripHydraTestCase_expectedType = Core.Name "expectedType" - --- | A test case for union type encoding and decoding, covering the various strategies for representing unions in Avro -data UnionTestCase = - UnionTestCase { - -- | A human-readable description of what this test case covers - unionTestCaseDescription :: String, - -- | The Hydra union type - unionTestCaseHydraType :: Core.Type, - -- | The expected Avro schema (enum for all-unit unions, record with optional fields for general unions) - unionTestCaseAvroSchema :: Schema.Schema, - -- | Pairs of corresponding Hydra terms and JSON values for this union - unionTestCaseTermPairs :: [(Core.Term, Model.Value)]} - deriving (Eq, Ord, Read, Show) - -_UnionTestCase = Core.Name "hydra.avro.testing.UnionTestCase" - -_UnionTestCase_description = Core.Name "description" - -_UnionTestCase_hydraType = Core.Name "hydraType" - -_UnionTestCase_avroSchema = Core.Name "avroSchema" - -_UnionTestCase_termPairs = Core.Name "termPairs" diff --git a/src/main/haskell/Hydra/Azure/Dtld.hs b/src/main/haskell/Hydra/Azure/Dtld.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Azure/Dtld.hs +++ /dev/null @@ -1,747 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | An Azure Digital Twin Definition Language (DTLD) model. Based on: --- | https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#digital-twins-definition-language --- | DTLD features which are not currently included in this model: --- | * geospatial schemas (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#geospatial-schemas) --- | * semantic types and units (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#semantic-types) --- | * model versioning (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#model-versioning) - -module Hydra.Azure.Dtld where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | A Command describes a function or operation that can be performed on any digital twin. -data Command = - Command { - -- | This must be 'Command' - commandType :: Iri, - -- | The 'programming' name of the command. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - commandName :: String, - -- | The ID of the command. If no @id is provided, the digital twin interface processor will assign one. - commandId :: (Maybe Dtmi), - -- | A comment for model authors - commandComment :: (Maybe String), - -- | A localizable description for display - commandDescription :: (Maybe String), - -- | A localizable name for display - commandDisplayName :: (Maybe String), - -- | This property is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time. - commandCommandType :: (Maybe CommandType), - -- | A description of the input to the Command - commandRequest :: (Maybe CommandPayload), - -- | A description of the output of the Command - commandResponse :: (Maybe CommandPayload)} - deriving (Eq, Ord, Read, Show) - -_Command = Core.Name "hydra.azure.dtld.Command" - -_Command_type = Core.Name "type" - -_Command_name = Core.Name "name" - -_Command_id = Core.Name "id" - -_Command_comment = Core.Name "comment" - -_Command_description = Core.Name "description" - -_Command_displayName = Core.Name "displayName" - -_Command_commandType = Core.Name "commandType" - -_Command_request = Core.Name "request" - -_Command_response = Core.Name "response" - --- | A CommandPayload describes the inputs to or the outputs from a Command. -data CommandPayload = - CommandPayload { - -- | The 'programming' name of the payload. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - commandPayloadName :: String, - -- | The data type of the payload - commandPayloadSchema :: Schema, - -- | The ID of the payload. If no @id is provided, the digital twin interface processor will assign one. - commandPayloadId :: (Maybe Dtmi), - -- | A comment for model authors - commandPayloadComment :: (Maybe String), - -- | A localizable description for display - commandPayloadDescription :: (Maybe String), - -- | A localizable name for display - commandPayloadDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_CommandPayload = Core.Name "hydra.azure.dtld.CommandPayload" - -_CommandPayload_name = Core.Name "name" - -_CommandPayload_schema = Core.Name "schema" - -_CommandPayload_id = Core.Name "id" - -_CommandPayload_comment = Core.Name "comment" - -_CommandPayload_description = Core.Name "description" - -_CommandPayload_displayName = Core.Name "displayName" - --- | CommandType is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time. -data CommandType = - CommandTypeSynchronous | - CommandTypeAsynchronous - deriving (Eq, Ord, Read, Show) - -_CommandType = Core.Name "hydra.azure.dtld.CommandType" - -_CommandType_synchronous = Core.Name "synchronous" - -_CommandType_asynchronous = Core.Name "asynchronous" - --- | Components enable interfaces to be composed of other interfaces. Components are different from relationships because they describe contents that are directly part of the interface. (A relationship describes a link between two interfaces.) -data Component = - Component { - -- | This must be 'Component' - componentType :: Iri, - -- | The 'programming' name of the component. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - componentName :: String, - -- | The data type of the component - componentSchema :: Interface, - -- | The ID of the component. If no @id is provided, the digital twin interface processor will assign one. - componentId :: (Maybe Dtmi), - -- | A comment for model authors - componentComment :: (Maybe String), - -- | A localizable description for display - componentDescription :: (Maybe String), - -- | A localizable name for display - componentDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Component = Core.Name "hydra.azure.dtld.Component" - -_Component_type = Core.Name "type" - -_Component_name = Core.Name "name" - -_Component_schema = Core.Name "schema" - -_Component_id = Core.Name "id" - -_Component_comment = Core.Name "comment" - -_Component_description = Core.Name "description" - -_Component_displayName = Core.Name "displayName" - --- | A digital twin model identifier -newtype Dtmi = - Dtmi { - unDtmi :: String} - deriving (Eq, Ord, Read, Show) - -_Dtmi = Core.Name "hydra.azure.dtld.Dtmi" - --- | An EnumValue describes an element of an Enum. -data EnumValue = - EnumValue { - -- | The 'programming' name of the enum value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - enumValueName :: String, - -- | The on-the-wire value that maps to the EnumValue. EnumValue may be either an integer or a string and must be unique for all enum values in this enum. - enumValueEnumValue :: IntegerOrString, - -- | The ID of the enum value. If no @id is provided, the digital twin interface processor will assign one. - enumValueId :: (Maybe Dtmi), - -- | A comment for model authors - enumValueComment :: (Maybe String), - -- | A localizable description for display - enumValueDescription :: (Maybe String), - -- | A localizable name for display - enumValueDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_EnumValue = Core.Name "hydra.azure.dtld.EnumValue" - -_EnumValue_name = Core.Name "name" - -_EnumValue_enumValue = Core.Name "enumValue" - -_EnumValue_id = Core.Name "id" - -_EnumValue_comment = Core.Name "comment" - -_EnumValue_description = Core.Name "description" - -_EnumValue_displayName = Core.Name "displayName" - --- | A Field describes a field in an Object. -data Field = - Field { - -- | The 'programming' name of the field. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - fieldName :: String, - -- | The data type of the field - fieldSchema :: Schema, - -- | The ID of the field. If no @id is provided, the digital twin interface processor will assign one. - fieldId :: (Maybe Dtmi), - -- | A comment for model authors - fieldComment :: (Maybe String), - -- | A localizable description for display - fieldDescription :: (Maybe String), - -- | A localizable name for display - fieldDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Field = Core.Name "hydra.azure.dtld.Field" - -_Field_name = Core.Name "name" - -_Field_schema = Core.Name "schema" - -_Field_id = Core.Name "id" - -_Field_comment = Core.Name "comment" - -_Field_description = Core.Name "description" - -_Field_displayName = Core.Name "displayName" - --- | A value which may be either an integer or a string -data IntegerOrString = - IntegerOrStringInteger Int | - IntegerOrStringString String - deriving (Eq, Ord, Read, Show) - -_IntegerOrString = Core.Name "hydra.azure.dtld.IntegerOrString" - -_IntegerOrString_integer = Core.Name "integer" - -_IntegerOrString_string = Core.Name "string" - --- | An Interface describes the contents (Telemetry, Properties, Commands, Relationships, and Components) of any digital twin. -data Interface = - Interface { - -- | A digital twin model identifier for the interface - interfaceId :: Dtmi, - -- | This must be 'Interface' - interfaceType :: Iri, - -- | The context to use when processing this interface. For this version, it must be set to 'dtmi:dtdl:context;2' - interfaceContext :: Iri, - -- | A comment for model authors - interfaceComment :: (Maybe String), - -- | A set of objects that define the contents (Telemetry, Properties, Commands, Relationships, and/or Components) of this interface - interfaceContents :: (Maybe (S.Set InterfaceContents)), - -- | A localizable description for display - interfaceDescription :: (Maybe String), - -- | A localizable name for display - interfaceDisplayName :: (Maybe String), - -- | A set of DTMIs that refer to interfaces this interface inherits from. Interfaces can inherit from multiple interfaces. - interfaceExtends :: (Maybe (S.Set Interface)), - -- | A set of IRIs or objects that refer to the reusable schemas within this interface. - interfaceSchemas :: (Maybe (S.Set SchemaInterface))} - deriving (Eq, Ord, Read, Show) - -_Interface = Core.Name "hydra.azure.dtld.Interface" - -_Interface_id = Core.Name "id" - -_Interface_type = Core.Name "type" - -_Interface_context = Core.Name "context" - -_Interface_comment = Core.Name "comment" - -_Interface_contents = Core.Name "contents" - -_Interface_description = Core.Name "description" - -_Interface_displayName = Core.Name "displayName" - -_Interface_extends = Core.Name "extends" - -_Interface_schemas = Core.Name "schemas" - --- | One of the kinds of content an Interface may contain: a Command, Component, Property, Relationship, or Telemetry -data InterfaceContents = - InterfaceContentsCommand Command | - InterfaceContentsComponent Component | - InterfaceContentsProperty Property | - InterfaceContentsRelationship Relationship | - InterfaceContentsTelemetry Telemetry - deriving (Eq, Ord, Read, Show) - -_InterfaceContents = Core.Name "hydra.azure.dtld.InterfaceContents" - -_InterfaceContents_command = Core.Name "command" - -_InterfaceContents_component = Core.Name "component" - -_InterfaceContents_property = Core.Name "property" - -_InterfaceContents_relationship = Core.Name "relationship" - -_InterfaceContents_telemetry = Core.Name "telemetry" - --- | An Internationalized Resource Identifier -newtype Iri = - Iri { - unIri :: String} - deriving (Eq, Ord, Read, Show) - -_Iri = Core.Name "hydra.azure.dtld.Iri" - --- | A MapKey describes the key in a Map. The schema of a MapKey must be string. -data MapKey = - MapKey { - -- | The 'programming' name of the map's key. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - mapKeyName :: String, - -- | The data type of the map's key - mapKeySchema :: Schema, - -- | The ID of the map key. If no @id is provided, the digital twin interface processor will assign one. - mapKeyId :: (Maybe Dtmi), - -- | A comment for model authors - mapKeyComment :: (Maybe String), - -- | A localizable description for display - mapKeyDescription :: (Maybe String), - -- | A localizable name for display - mapKeyDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_MapKey = Core.Name "hydra.azure.dtld.MapKey" - -_MapKey_name = Core.Name "name" - -_MapKey_schema = Core.Name "schema" - -_MapKey_id = Core.Name "id" - -_MapKey_comment = Core.Name "comment" - -_MapKey_description = Core.Name "description" - -_MapKey_displayName = Core.Name "displayName" - --- | A MapValue describes the values in a Map. -data MapValue = - MapValue { - -- | The 'programming' name of the map's value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - mapValueName :: String, - -- | The data type of the map's values - mapValueSchema :: Schema, - -- | The ID of the map value. If no @id is provided, the digital twin interface processor will assign one. - mapValueId :: (Maybe Dtmi), - -- | A comment for model authors - mapValueComment :: (Maybe String), - -- | A localizable description for display - mapValueDescription :: (Maybe String), - -- | A localizable name for display - mapValueDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_MapValue = Core.Name "hydra.azure.dtld.MapValue" - -_MapValue_name = Core.Name "name" - -_MapValue_schema = Core.Name "schema" - -_MapValue_id = Core.Name "id" - -_MapValue_comment = Core.Name "comment" - -_MapValue_description = Core.Name "description" - -_MapValue_displayName = Core.Name "displayName" - --- | A Property describes the read-only and read/write state of any digital twin. For example, a device serial number may be a read-only property, the desired temperature on a thermostat may be a read-write property; and the name of a room may be a read-write property. -data Property = - Property { - -- | This must at least be 'Property'. It can also include a semantic type. - propertyType :: Iri, - -- | The 'programming' name of the property. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.. - propertyName :: String, - -- | The data type of the Property - propertySchema :: Schema, - -- | The ID of the property. If no @id is provided, the digital twin interface processor will assign one. - propertyId :: (Maybe Dtmi), - -- | A comment for model authors - propertyComment :: (Maybe String), - -- | A localizable description for display - propertyDescription :: (Maybe String), - -- | A localizable name for display - propertyDisplayName :: (Maybe String), - -- | The unit type of the property. A semantic type is required for the unit property to be available. - propertyUnit :: (Maybe Unit), - -- | A boolean value that indicates whether the property is writable by an external source, such as an application, or not. The default value is false (read-only). - propertyWritable :: (Maybe Bool)} - deriving (Eq, Ord, Read, Show) - -_Property = Core.Name "hydra.azure.dtld.Property" - -_Property_type = Core.Name "type" - -_Property_name = Core.Name "name" - -_Property_schema = Core.Name "schema" - -_Property_id = Core.Name "id" - -_Property_comment = Core.Name "comment" - -_Property_description = Core.Name "description" - -_Property_displayName = Core.Name "displayName" - -_Property_unit = Core.Name "unit" - -_Property_writable = Core.Name "writable" - --- | A Relationship describes a link to another digital twin and enables graphs of digital twins to be created. Relationships are different from Components because they describe a link to a separate digital twin. -data Relationship = - Relationship { - -- | This must be 'Relationship' - relationshipType :: Iri, - -- | The 'programming' name of the relationship. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. - relationshipName :: String, - -- | The ID of the relationship description. If no @id is provided, the digital twin interface processor will assign one. - relationshipId :: (Maybe Dtmi), - -- | A comment for model authors - relationshipComment :: (Maybe String), - -- | A localizable description for display - relationshipDescription :: (Maybe String), - -- | A localizable name for display - relationshipDisplayName :: (Maybe String), - -- | The maximum multiplicity for the target of the relationship. The default value is infinite (there may be an unlimited number of relationship instances for this relationship). - relationshipMaxMultiplicity :: (Maybe Int), - -- | The minimum multiplicity for the target of the relationship. The default value is 0 (this relationship is permitted to have no instances). In DTDL v2, minMultiplicity must always be 0. - relationshipMinMultiplicity :: (Maybe Int), - -- | A set of Properties that define relationship-specific state - relationshipProperties :: (Maybe (S.Set Property)), - -- | An interface ID. The default value (when target is not specified) is that the target may be any interface. - relationshipTarget :: (Maybe Interface), - -- | A boolean value that indicates whether the relationship is writable by an external source, such as an application, or not. The default value is false (read-only). - relationshipWritable :: (Maybe Bool)} - deriving (Eq, Ord, Read, Show) - -_Relationship = Core.Name "hydra.azure.dtld.Relationship" - -_Relationship_type = Core.Name "type" - -_Relationship_name = Core.Name "name" - -_Relationship_id = Core.Name "id" - -_Relationship_comment = Core.Name "comment" - -_Relationship_description = Core.Name "description" - -_Relationship_displayName = Core.Name "displayName" - -_Relationship_maxMultiplicity = Core.Name "maxMultiplicity" - -_Relationship_minMultiplicity = Core.Name "minMultiplicity" - -_Relationship_properties = Core.Name "properties" - -_Relationship_target = Core.Name "target" - -_Relationship_writable = Core.Name "writable" - --- | Schemas are used to describe the on-the-wire or serialized format of the data in a digital twin interface. A full set of primitive data types are provided, along with support for a variety of complex schemas in the forms of Arrays, Enums, Maps, and Objects. Schemas described through digital twin's schema definition language are compatible with popular serialization formats, including JSON, Avro, and Protobuf. -data Schema = - SchemaPrimitive_ SchemaPrimitive | - SchemaComplex_ SchemaComplex - deriving (Eq, Ord, Read, Show) - -_Schema = Core.Name "hydra.azure.dtld.Schema" - -_Schema_primitive = Core.Name "primitive" - -_Schema_complex = Core.Name "complex" - --- | An Array describes an indexable data type where each element is of the same schema. An Array elements' schema can itself be a primitive or complex schema. -data SchemaArray = - SchemaArray { - -- | This must be 'Array' - schemaArrayType :: Iri, - -- | The data type of the array elements - schemaArrayElementSchema :: Schema, - -- | The ID of the array. If no @id is provided, the digital twin interface processor will assign one. - schemaArrayId :: (Maybe Dtmi), - -- | A comment for model authors - schemaArrayComment :: (Maybe String), - -- | A localizable description for display - schemaArrayDescription :: (Maybe String), - -- | A localizable name for display - schemaArrayDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_SchemaArray = Core.Name "hydra.azure.dtld.SchemaArray" - -_SchemaArray_type = Core.Name "type" - -_SchemaArray_elementSchema = Core.Name "elementSchema" - -_SchemaArray_id = Core.Name "id" - -_SchemaArray_comment = Core.Name "comment" - -_SchemaArray_description = Core.Name "description" - -_SchemaArray_displayName = Core.Name "displayName" - --- | Complex schemas are designed for supporting complex data types made up of primitive data types. Currently the following complex schemas are provided: Array, Enum, Map, and Object. A complex schema can be specified directly as the value in a schema statement or described in the interface schemas set and referenced in the schema statement. -data SchemaComplex = - SchemaComplexArray SchemaArray | - SchemaComplexEnum SchemaEnum | - SchemaComplexMap SchemaMap | - SchemaComplexObject SchemaObject - deriving (Eq, Ord, Read, Show) - -_SchemaComplex = Core.Name "hydra.azure.dtld.SchemaComplex" - -_SchemaComplex_array = Core.Name "array" - -_SchemaComplex_enum = Core.Name "enum" - -_SchemaComplex_map = Core.Name "map" - -_SchemaComplex_object = Core.Name "object" - --- | An Enum describes a data type with a set of named labels that map to values. The values in an Enum can be either integers or strings, but the labels are always strings. -data SchemaEnum = - SchemaEnum { - -- | Enum - schemaEnumType :: Iri, - -- | A set of enum value and label mappings - schemaEnumEnumValues :: [EnumValue], - -- | The data type for the enum values. All enum values must be of the same type. - schemaEnumValueSchema :: IntegerOrString, - -- | The ID of the enum. If no @id is provided, the digital twin interface processor will assign one. - schemaEnumId :: (Maybe Dtmi), - -- | A comment for model authors - schemaEnumComment :: (Maybe String), - -- | A localizable description for display - schemaEnumDescription :: (Maybe String), - -- | A localizable name for display - schemaEnumDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_SchemaEnum = Core.Name "hydra.azure.dtld.SchemaEnum" - -_SchemaEnum_type = Core.Name "type" - -_SchemaEnum_enumValues = Core.Name "enumValues" - -_SchemaEnum_valueSchema = Core.Name "valueSchema" - -_SchemaEnum_id = Core.Name "id" - -_SchemaEnum_comment = Core.Name "comment" - -_SchemaEnum_description = Core.Name "description" - -_SchemaEnum_displayName = Core.Name "displayName" - --- | Within an interface definition, complex schemas may be defined for reusability across Telemetry, Properties, and Commands. This is designed to promote readability and improved maintenance because schemas that are reused can be defined once (per interface). Interface schemas are defined in the schemas property of an interface. -data SchemaInterface = - SchemaInterface { - -- | The globally unique identifier for the schema - schemaInterfaceId :: Dtmi, - -- | The type of complex schema. This must refer to one of the complex schema classes (Array, Enum, Map, or Object). - schemaInterfaceType :: SchemaInterfaceType, - -- | A comment for model authors - schemaInterfaceComment :: (Maybe String), - -- | A localizable description for display - schemaInterfaceDescription :: (Maybe String), - -- | A localizable name for display - schemaInterfaceDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_SchemaInterface = Core.Name "hydra.azure.dtld.SchemaInterface" - -_SchemaInterface_id = Core.Name "id" - -_SchemaInterface_type = Core.Name "type" - -_SchemaInterface_comment = Core.Name "comment" - -_SchemaInterface_description = Core.Name "description" - -_SchemaInterface_displayName = Core.Name "displayName" - --- | The type of a reusable interface schema: Array, Enum, Map, or Object -data SchemaInterfaceType = - SchemaInterfaceTypeArray SchemaArray | - SchemaInterfaceTypeEnum SchemaEnum | - SchemaInterfaceTypeMap SchemaMap | - SchemaInterfaceTypeObject SchemaObject - deriving (Eq, Ord, Read, Show) - -_SchemaInterfaceType = Core.Name "hydra.azure.dtld.SchemaInterfaceType" - -_SchemaInterfaceType_array = Core.Name "array" - -_SchemaInterfaceType_enum = Core.Name "enum" - -_SchemaInterfaceType_map = Core.Name "map" - -_SchemaInterfaceType_object = Core.Name "object" - --- | A Map describes a data type of key-value pairs where the values share the same schema. The key in a Map must be a string. The values in a Map can be any schema. -data SchemaMap = - SchemaMap { - -- | Map - schemaMapType :: Iri, - -- | A description of the keys in the map - schemaMapMapKey :: MapKey, - -- | A description of the values in the map - schemaMapMapValue :: MapValue, - -- | The ID of the map. If no @id is provided, the digital twin interface processor will assign one. - schemaMapId :: (Maybe Dtmi), - -- | A comment for model authors - schemaMapComment :: (Maybe String), - -- | A localizable description for display - schemaMapDescription :: (Maybe String), - -- | A localizable name for display - schemaMapDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_SchemaMap = Core.Name "hydra.azure.dtld.SchemaMap" - -_SchemaMap_type = Core.Name "type" - -_SchemaMap_mapKey = Core.Name "mapKey" - -_SchemaMap_mapValue = Core.Name "mapValue" - -_SchemaMap_id = Core.Name "id" - -_SchemaMap_comment = Core.Name "comment" - -_SchemaMap_description = Core.Name "description" - -_SchemaMap_displayName = Core.Name "displayName" - --- | An Object describes a data type made up of named fields (like a struct in C). The fields in an Object map can be primitive or complex schemas. -data SchemaObject = - SchemaObject { - -- | Object - schemaObjectType :: Iri, - -- | A set of field descriptions, one for each field in the Object - schemaObjectFields :: (S.Set Field), - -- | The ID of the object. If no @id is provided, the digital twin interface processor will assign one. - schemaObjectId :: (Maybe Dtmi), - -- | A comment for model authors - schemaObjectComment :: (Maybe String), - -- | A localizable description for display - schemaObjectDescription :: (Maybe String), - -- | A localizable name for display - schemaObjectDisplayName :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_SchemaObject = Core.Name "hydra.azure.dtld.SchemaObject" - -_SchemaObject_type = Core.Name "type" - -_SchemaObject_fields = Core.Name "fields" - -_SchemaObject_id = Core.Name "id" - -_SchemaObject_comment = Core.Name "comment" - -_SchemaObject_description = Core.Name "description" - -_SchemaObject_displayName = Core.Name "displayName" - --- | A full set of primitive data types are provided and can be specified directly as the value in a schema statement in a digital twin interface. -data SchemaPrimitive = - -- | A boolean value - SchemaPrimitiveBoolean | - -- | A full-date as defined in section 5.6 of RFC 3339 - SchemaPrimitiveDate | - -- | A date-time as defined in RFC 3339 - SchemaPrimitiveDateTime | - -- | An IEEE 8-byte floating point - SchemaPrimitiveDouble | - -- | A duration in ISO 8601 format - SchemaPrimitiveDuration | - -- | An IEEE 4-byte floating point - SchemaPrimitiveFloat | - -- | A signed 4-byte integer - SchemaPrimitiveInteger | - -- | A signed 8-byte integer - SchemaPrimitiveLong | - -- | A UTF8 string - SchemaPrimitiveString | - -- | A full-time as defined in section 5.6 of RFC 3339 - SchemaPrimitiveTime - deriving (Eq, Ord, Read, Show) - -_SchemaPrimitive = Core.Name "hydra.azure.dtld.SchemaPrimitive" - -_SchemaPrimitive_boolean = Core.Name "boolean" - -_SchemaPrimitive_date = Core.Name "date" - -_SchemaPrimitive_dateTime = Core.Name "dateTime" - -_SchemaPrimitive_double = Core.Name "double" - -_SchemaPrimitive_duration = Core.Name "duration" - -_SchemaPrimitive_float = Core.Name "float" - -_SchemaPrimitive_integer = Core.Name "integer" - -_SchemaPrimitive_long = Core.Name "long" - -_SchemaPrimitive_string = Core.Name "string" - -_SchemaPrimitive_time = Core.Name "time" - --- | Telemetry describes the data emitted by any digital twin, whether the data is a regular stream of sensor readings or a computed stream of data, such as occupancy, or an occasional error or information message. -data Telemetry = - Telemetry { - -- | This must be at least 'Telemetry'. It can also include a semantic type - telemetryType :: Iri, - -- | The 'programming' name of the telemetry. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.. - telemetryName :: String, - -- | The data type of the Telemetry - telemetrySchema :: Schema, - -- | The ID of the telemetry. If no @id is provided, the digital twin interface processor will assign one. - telemetryId :: (Maybe Dtmi), - -- | A comment for model authors - telemetryComment :: (Maybe String), - -- | A localizable description for display - telemetryDescription :: (Maybe String), - -- | A localizable name for display - telemetryDisplayName :: (Maybe String), - -- | The unit type of the Telemetry. A semantic type is required for the unit property to be available. - telemetryUnit :: (Maybe Unit)} - deriving (Eq, Ord, Read, Show) - -_Telemetry = Core.Name "hydra.azure.dtld.Telemetry" - -_Telemetry_type = Core.Name "type" - -_Telemetry_name = Core.Name "name" - -_Telemetry_schema = Core.Name "schema" - -_Telemetry_id = Core.Name "id" - -_Telemetry_comment = Core.Name "comment" - -_Telemetry_description = Core.Name "description" - -_Telemetry_displayName = Core.Name "displayName" - -_Telemetry_unit = Core.Name "unit" - --- | The unit type of a Property or Telemetry value, available when a semantic type is present -newtype Unit = - Unit { - unUnit :: ()} - deriving (Eq, Ord, Read, Show) - -_Unit = Core.Name "hydra.azure.dtld.Unit" diff --git a/src/main/haskell/Hydra/Cpp/Coder.hs b/src/main/haskell/Hydra/Cpp/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Coder.hs +++ /dev/null @@ -1,746 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | C++ code generator: converts Hydra modules to C++ header files - -module Hydra.Cpp.Coder where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Cpp.Language as Language -import qualified Hydra.Cpp.Serde as Serde -import qualified Hydra.Cpp.Syntax as Syntax -import qualified Hydra.Decode.Core as DecodeCore -import qualified Hydra.Dependencies as Dependencies -import qualified Hydra.Docs as Docs -import qualified Hydra.Encode.Core as EncodeCore -import qualified Hydra.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -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.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Predicates as Predicates -import qualified Hydra.Print.Core as PrintCore -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Resolution as Resolution -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Convert a binding name to a file path -bindingNameToFilePath :: Core.Name -> String -bindingNameToFilePath name = - Names.nameToFilePath Util.CaseConventionLowerSnake Util.CaseConventionLowerSnake (File.FileExtension "h") name - --- | Get the class name from a fully qualified Name -className :: Core.Name -> String -className name = sanitizeCppName (Names.localNameOf name) - --- | Create a const reference parameter -constParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter -constParameter name typ = - Syntax.Parameter { - Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = typ, - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), - Syntax.parameterName = name, - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing} - --- | Create a class declaration -cppClassDeclaration :: String -> [Syntax.BaseSpecifier] -> Maybe Syntax.ClassBody -> Syntax.Declaration -cppClassDeclaration name baseSpecs mbody = - Syntax.DeclarationClass (Syntax.ClassDeclaration { - Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { - Syntax.classSpecifierKey = Syntax.ClassKeyClass, - Syntax.classSpecifierName = name, - Syntax.classSpecifierInheritance = baseSpecs}, - Syntax.classDeclarationBody = mbody}) - --- | Create an enum class declaration -cppEnumDeclaration :: String -> Maybe Syntax.ClassBody -> Syntax.Declaration -cppEnumDeclaration name mbody = - Syntax.DeclarationClass (Syntax.ClassDeclaration { - Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { - Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, - Syntax.classSpecifierName = name, - Syntax.classSpecifierInheritance = []}, - Syntax.classDeclarationBody = mbody}) - --- | Create an enum forward declaration (no body) -cppEnumForwardDeclaration :: String -> Syntax.Declaration -cppEnumForwardDeclaration name = cppEnumDeclaration name Nothing - --- | Convert a PostfixExpression to a full Expression -cppPostfixExpressionToCppExpression :: Syntax.PostfixExpression -> Syntax.Expression -cppPostfixExpressionToCppExpression pe = cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionPostfix pe) - --- | Convert a PrimaryExpression to a full Expression -cppPrimaryExpressionToCppExpression :: Syntax.PrimaryExpression -> Syntax.Expression -cppPrimaryExpressionToCppExpression prim = cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary prim) - --- | Convert a UnaryExpression to a full Expression -cppUnaryExpressionToCppExpression :: Syntax.UnaryExpression -> Syntax.Expression -cppUnaryExpressionToCppExpression ue = - Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression ue))) - --- | Convert a UnaryExpression to a LogicalOrExpression -cppUnaryExpressionToCppLogicalOrExpression :: Syntax.UnaryExpression -> Syntax.LogicalOrExpression -cppUnaryExpressionToCppLogicalOrExpression ue = - Syntax.LogicalOrExpressionLogicalAnd (Syntax.LogicalAndExpressionInclusiveOr (Syntax.InclusiveOrExpressionExclusiveOr (Syntax.ExclusiveOrExpressionAnd (Syntax.AndExpressionEquality (Syntax.EqualityExpressionRelational (Syntax.RelationalExpressionShift (Syntax.ShiftExpressionAdditive (Syntax.AdditiveExpressionMultiplicative (Syntax.MultiplicativeExpressionUnary ue))))))))) - --- | Create the accept() method implementation using a dynamic_cast chain -createAcceptImplementation :: Core.Name -> [Core.FieldType] -> Syntax.Declaration -createAcceptImplementation tname variants = - Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { - Syntax.templateDeclarationInline = False, - Syntax.templateDeclarationParameters = [ - "typename R"], - Syntax.templateDeclarationDeclaration = (Syntax.DeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), - Syntax.functionDeclarationName = (Strings.concat2 (className tname) "::accept"), - Syntax.functionDeclarationParameters = [ - Syntax.Parameter { - Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName tname) ""))), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), - Syntax.parameterName = "visitor", - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}], - Syntax.functionDeclarationSuffixSpecifiers = [ - Syntax.FunctionSpecifierSuffixConst], - Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement (Lists.map (\ft -> - let fname = Core.fieldTypeName ft - in (Syntax.StatementSelection (Syntax.SelectionStatement { - Syntax.selectionStatementCondition = (Syntax.ExpressionAssignment (Syntax.AssignmentExpressionAssignment (Syntax.ExplicitAssignment { - Syntax.explicitAssignmentLeft = (cppUnaryExpressionToCppLogicalOrExpression (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "auto ptr")))), - Syntax.explicitAssignmentOp = Syntax.AssignmentOperatorAssign, - Syntax.explicitAssignmentRight = (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier (Strings.concat2 (Strings.concat2 "dynamic_cast"))), - Syntax.functionCallOperationArguments = [ - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier "this")]}))))))}))), - Syntax.selectionStatementThenBranch = (Syntax.StatementCompound (Syntax.CompoundStatement [ - Syntax.StatementJump (Syntax.JumpStatementReturnValue (cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { - Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "visitor")), - Syntax.memberAccessOperationMember = "visit"})), - Syntax.functionCallOperationArguments = [ - cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionUnaryOp (Syntax.UnaryOperation { - Syntax.unaryOperationOperator = Syntax.UnaryOperatorDereference, - Syntax.unaryOperationOperand = (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "ptr")))}))]}))))])), - Syntax.selectionStatementElseBranch = (Just (createThrowStmt "std::runtime_error" createTypeIdNameCall))}))) variants)))}))}) - --- | Create a constructor function body: default if no params, empty compound otherwise -createConstructorBody :: [t0] -> Syntax.FunctionBody -createConstructorBody params = - Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [])) - --- | Create a function call expression -createFunctionCallExpr :: String -> [Syntax.Expression] -> Syntax.Expression -createFunctionCallExpr funcName args = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier funcName)), - Syntax.functionCallOperationArguments = args})) - --- | Create a header file with pragma once, includes, and declarations -createHeaderFile :: [Syntax.IncludeDirective] -> [Syntax.Declaration] -> Syntax.Program -createHeaderFile includes decls = - Syntax.Program { - Syntax.programPreprocessorDirectives = [ - Syntax.PreprocessorDirectivePragma (Syntax.PragmaDirective { - Syntax.pragmaDirectiveContent = "once"})], - Syntax.programIncludes = includes, - Syntax.programDeclarations = decls} - --- | Create an identifier expression -createIdentifierExpr :: String -> Syntax.Expression -createIdentifierExpr name = cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier name) - --- | Create a less-than operator for a record type (trivial/placeholder implementation) -createLessThanOperator :: Core.Name -> t0 -> Syntax.Declaration -createLessThanOperator typeName fields = - Syntax.DeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [ - Syntax.FunctionSpecifierPrefixInline], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic Syntax.BasicTypeBool), - Syntax.functionDeclarationName = "operator<", - Syntax.functionDeclarationParameters = [ - unnamedParameter "lhs" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className typeName))), - (unnamedParameter "rhs" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className typeName))))], - Syntax.functionDeclarationSuffixSpecifiers = [], - Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [ - Syntax.StatementJump (Syntax.JumpStatementReturnValue (createLiteralBoolExpr False))]))}) - --- | Create a boolean literal expression -createLiteralBoolExpr :: Bool -> Syntax.Expression -createLiteralBoolExpr val = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralBoolean (Syntax.BooleanLiteral val))) - --- | Create an integer literal expression -createLiteralIntExpr :: Integer -> Syntax.Expression -createLiteralIntExpr val = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteralDecimal val))) - --- | Create a partial visitor interface with default visit methods that delegate to otherwise() -createPartialVisitorInterface :: Core.Name -> [Core.FieldType] -> Syntax.Declaration -createPartialVisitorInterface tname variants = - Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { - Syntax.templateDeclarationInline = False, - Syntax.templateDeclarationParameters = [ - "typename R"], - Syntax.templateDeclarationDeclaration = (cppClassDeclaration (partialVisitorName tname) [ - Syntax.BaseSpecifier { - Syntax.baseSpecifierAccess = Syntax.AccessSpecifierPublic, - Syntax.baseSpecifierName = (Strings.concat2 (visitorName tname) "")}] (Just (Syntax.ClassBody (Lists.concat [ - [ - memberSpecificationPublic], - [ - Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [ - Syntax.FunctionSpecifierPrefixVirtual], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), - Syntax.functionDeclarationName = "otherwise", - Syntax.functionDeclarationParameters = [ - constParameter "value" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className tname)))], - Syntax.functionDeclarationSuffixSpecifiers = [ - Syntax.FunctionSpecifierSuffixConst], - Syntax.functionDeclarationBody = Syntax.FunctionBodyPure}))], - (Lists.map (\ft -> - let fname = Core.fieldTypeName ft - in (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), - Syntax.functionDeclarationName = "visit", - Syntax.functionDeclarationParameters = [ - constParameter "value" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (variantName tname fname)))], - Syntax.functionDeclarationSuffixSpecifiers = [ - Syntax.FunctionSpecifierSuffixOverride], - Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [ - Syntax.StatementJump (Syntax.JumpStatementReturnValue (createFunctionCallExpr "otherwise" [ - createIdentifierExpr "value"]))]))})))) variants)]))))}) - --- | Create a template type (e.g. std::vector) -createTemplateType :: String -> [Syntax.TypeExpression] -> Syntax.TypeExpression -createTemplateType name args = - Syntax.TypeExpressionTemplate (Syntax.TemplateType { - Syntax.templateTypeName = name, - Syntax.templateTypeArguments = (Lists.map (\a -> Syntax.TemplateArgumentType a) args)}) - --- | Create a throw statement -createThrowStmt :: String -> Syntax.Expression -> Syntax.Statement -createThrowStmt exceptionType arg = - Syntax.StatementJump (Syntax.JumpStatementThrow (createFunctionCallExpr exceptionType [ - arg])) - --- | Create a typeid(*this).name() call expression -createTypeIdNameCall :: Syntax.Expression -createTypeIdNameCall = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { - Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "typeid")), - Syntax.functionCallOperationArguments = [ - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized (cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "*this"))))]})), - Syntax.memberAccessOperationMember = "name"})), - Syntax.functionCallOperationArguments = []})) - --- | Create a type reference, optionally as a shared_ptr for struct types -createTypeReference :: Bool -> Core.Name -> Syntax.TypeExpression -createTypeReference isPointer name = - Logic.ifElse isPointer (createTemplateType "std::shared_ptr" [ - toConstType (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Names.localNameOf name))))]) (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Names.localNameOf name)))) - --- | Create the union base class with protected constructor, virtual destructor, and accept method -createUnionBaseClass :: Core.Name -> t0 -> Syntax.Declaration -createUnionBaseClass name variants = - cppClassDeclaration (className name) [] (Just (Syntax.ClassBody [ - memberSpecificationProtected, - (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { - Syntax.constructorDeclarationName = (className name), - Syntax.constructorDeclarationParameters = [], - Syntax.constructorDeclarationInitializers = [], - Syntax.constructorDeclarationBody = Syntax.FunctionBodyDefault}))), - memberSpecificationPublic, - (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationDestructor (Syntax.DestructorDeclaration { - Syntax.destructorDeclarationPrefixSpecifiers = [ - Syntax.FunctionSpecifierPrefixVirtual], - Syntax.destructorDeclarationName = (className name), - Syntax.destructorDeclarationSuffixSpecifiers = [], - Syntax.destructorDeclarationBody = Syntax.FunctionBodyDefault}))), - (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationTemplate (Syntax.TemplateDeclaration { - Syntax.templateDeclarationInline = False, - Syntax.templateDeclarationParameters = [ - "typename R"], - Syntax.templateDeclarationDeclaration = (Syntax.DeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), - Syntax.functionDeclarationName = "accept", - Syntax.functionDeclarationParameters = [ - Syntax.Parameter { - Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName name) ""))), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), - Syntax.parameterName = "visitor", - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}], - Syntax.functionDeclarationSuffixSpecifiers = [ - Syntax.FunctionSpecifierSuffixConst], - Syntax.functionDeclarationBody = Syntax.FunctionBodyDeclaration}))})))])) - --- | Create a variant subclass (one branch of a union type) -createVariantClass :: t0 -> t1 -> Core.Name -> Core.Name -> Core.FieldType -> Either Errors.Error Syntax.Declaration -createVariantClass cx g tname parentClass ft = - - let fname = Core.fieldTypeName ft - variantType = Core.fieldTypeType ft - hasValue = Logic.not (Predicates.isUnitType variantType) - valueField = - Logic.ifElse hasValue (Eithers.map (\cppType -> [ - Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable (Syntax.VariableDeclaration { - Syntax.variableDeclarationType = (Just cppType), - Syntax.variableDeclarationName = "value", - Syntax.variableDeclarationInitializer = Nothing, - Syntax.variableDeclarationIsAuto = False}))]) (encodeType cx g (Strip.deannotateType variantType))) (Right []) - constructorParams = - Logic.ifElse hasValue (Eithers.map (\paramType -> [ - Syntax.Parameter { - Syntax.parameterType = paramType, - Syntax.parameterName = "value", - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}]) (encodeType cx g (Strip.deannotateType variantType))) (Right []) - in (Eithers.bind valueField (\vFields -> Eithers.bind constructorParams (\vParams -> - let initList = - Logic.ifElse hasValue [ - Syntax.MemInitializer { - Syntax.memInitializerName = "value", - Syntax.memInitializerArguments = [ - createIdentifierExpr "value"]}] [] - in (Right (cppClassDeclaration (variantName tname fname) [ - Syntax.BaseSpecifier { - Syntax.baseSpecifierAccess = Syntax.AccessSpecifierPublic, - Syntax.baseSpecifierName = (className parentClass)}] (Just (Syntax.ClassBody (Lists.concat [ - [ - memberSpecificationPublic], - vFields, - [ - Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { - Syntax.constructorDeclarationName = (variantName tname fname), - Syntax.constructorDeclarationParameters = vParams, - Syntax.constructorDeclarationInitializers = initList, - Syntax.constructorDeclarationBody = (createConstructorBody vParams)}))]])))))))) - --- | Create a visitor interface with pure virtual visit methods -createVisitorInterface :: Core.Name -> [Core.FieldType] -> Syntax.Declaration -createVisitorInterface tname variants = - Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { - Syntax.templateDeclarationInline = False, - Syntax.templateDeclarationParameters = [ - "typename R"], - Syntax.templateDeclarationDeclaration = (cppClassDeclaration (visitorName tname) [] (Just (Syntax.ClassBody (Lists.concat [ - [ - memberSpecificationPublic], - (Lists.map (\ft -> - let fname = Core.fieldTypeName ft - in (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { - Syntax.functionDeclarationPrefixSpecifiers = [ - Syntax.FunctionSpecifierPrefixVirtual], - Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), - Syntax.functionDeclarationName = "visit", - Syntax.functionDeclarationParameters = [ - Syntax.Parameter { - Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (variantName tname fname))), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), - Syntax.parameterName = "value", - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}], - Syntax.functionDeclarationSuffixSpecifiers = [], - Syntax.functionDeclarationBody = Syntax.FunctionBodyPure})))) variants), - [ - Syntax.MemberSpecificationMember (Syntax.MemberDeclarationDestructor (Syntax.DestructorDeclaration { - Syntax.destructorDeclarationPrefixSpecifiers = [ - Syntax.FunctionSpecifierPrefixVirtual], - Syntax.destructorDeclarationName = (visitorName tname), - Syntax.destructorDeclarationSuffixSpecifiers = [], - Syntax.destructorDeclarationBody = Syntax.FunctionBodyDefault}))]]))))}) - --- | Encode a type application (template instantiation) -encodeApplicationType :: t0 -> t1 -> Core.ApplicationType -> Either Errors.Error Syntax.TypeExpression -encodeApplicationType cx g at = - Eithers.bind (encodeType cx g (Core.applicationTypeFunction at)) (\body -> Eithers.bind (encodeType cx g (Core.applicationTypeArgument at)) (\arg -> Right (createTemplateType "TODO_template" [ - body, - arg]))) - --- | Encode an enum type as a C++ enum class -encodeEnumType :: t0 -> t1 -> Core.Name -> [Core.FieldType] -> t2 -> Either t3 [Syntax.Declaration] -encodeEnumType cx g name tfields comment = - Right [ - cppEnumDeclaration (className name) (Just (Syntax.ClassBody (Lists.map (\ft -> Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable (Syntax.VariableDeclaration { - Syntax.variableDeclarationType = Nothing, - Syntax.variableDeclarationName = (encodeEnumValue (Core.fieldTypeName ft)), - Syntax.variableDeclarationInitializer = Nothing, - Syntax.variableDeclarationIsAuto = False}))) tfields)))] - --- | Encode an enum value in UPPER_SNAKE_CASE -encodeEnumValue :: Core.Name -> String -encodeEnumValue fname = sanitizeCppName (Formatting.convertCaseCamelToUpperSnake (Core.unName fname)) - --- | Encode a field name in lower_snake_case -encodeFieldName :: Core.Name -> String -encodeFieldName fname = sanitizeCppName (Formatting.convertCaseCamelToLowerSnake (Core.unName fname)) - --- | Encode a field type as a VariableDeclaration -encodeFieldType :: t0 -> Core.FieldType -> t1 -> t2 -> Either Errors.Error Syntax.VariableDeclaration -encodeFieldType isParameter ft cx g = - - let fname = Core.fieldTypeName ft - ftype = Core.fieldTypeType ft - in (Eithers.bind (encodeType cx g ftype) (\cppType -> Right (Syntax.VariableDeclaration { - Syntax.variableDeclarationType = (Just cppType), - Syntax.variableDeclarationName = (encodeFieldName fname), - Syntax.variableDeclarationInitializer = Nothing, - Syntax.variableDeclarationIsAuto = False}))) - --- | Encode a forall type (strip the quantifier) -encodeForallType :: t0 -> t1 -> Core.ForallType -> Either Errors.Error Syntax.TypeExpression -encodeForallType cx g lt = encodeType cx g (Core.forallTypeBody lt) - --- | Encode a function type as std::function -encodeFunctionType :: t0 -> t1 -> Core.FunctionType -> Either Errors.Error Syntax.TypeExpression -encodeFunctionType cx g ft = - Eithers.bind (encodeType cx g (Core.functionTypeDomain ft)) (\dom -> Eithers.bind (encodeType cx g (Core.functionTypeCodomain ft)) (\cod -> Right (Syntax.TypeExpressionFunction (Syntax.FunctionType { - Syntax.functionTypeReturnType = cod, - Syntax.functionTypeParameters = [ - Syntax.Parameter { - Syntax.parameterType = dom, - Syntax.parameterName = "", - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}]})))) - --- | Encode a literal type as a C++ type expression -encodeLiteralType :: Core.LiteralType -> Syntax.TypeExpression -encodeLiteralType lt = - Syntax.TypeExpressionBasic (case lt of - Core.LiteralTypeBinary -> Syntax.BasicTypeChar - Core.LiteralTypeBoolean -> Syntax.BasicTypeBool - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat32 -> Syntax.BasicTypeFloat - Core.FloatTypeFloat64 -> Syntax.BasicTypeDouble - _ -> Syntax.BasicTypeDouble - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeBigint -> Syntax.BasicTypeInt - Core.IntegerTypeInt8 -> Syntax.BasicTypeChar - Core.IntegerTypeInt16 -> Syntax.BasicTypeNamed "int16_t" - Core.IntegerTypeInt32 -> Syntax.BasicTypeInt - Core.IntegerTypeInt64 -> Syntax.BasicTypeNamed "int64_t" - _ -> Syntax.BasicTypeInt - Core.LiteralTypeString -> Syntax.BasicTypeString) - --- | Encode a name with a specified case convention, optionally qualified -encodeName :: t0 -> t1 -> t2 -> Core.Name -> String -encodeName isQualified conv env name = sanitizeCppName (Names.localNameOf name) - --- | Encode a namespace as a C++ namespace string (e.g. "hydra.cpp" -> "hydra::cpp") -encodeNamespace :: Packaging.ModuleName -> String -encodeNamespace ns = - Strings.join "::" (Lists.map (\seg -> Formatting.convertCaseCamelToLowerSnake seg) (Strings.splitOn "." (Packaging.unModuleName ns))) - --- | Encode a record type as a C++ class with fields and constructor -encodeRecordType :: t0 -> t1 -> Core.Name -> [Core.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] -encodeRecordType cx g name rt comment = - Eithers.bind (Eithers.mapList (\f -> encodeFieldType False f cx g) rt) (\cppFields -> Eithers.bind (Eithers.mapList (\f -> encodeFieldType True f cx g) rt) (\constructorParams -> Right [ - cppClassDeclaration (className name) [] (Just (Syntax.ClassBody (Lists.concat [ - [ - memberSpecificationPublic], - (Lists.map (\field -> Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable field)) cppFields), - [ - Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { - Syntax.constructorDeclarationName = (className name), - Syntax.constructorDeclarationParameters = (Lists.map (\p -> Syntax.Parameter { - Syntax.parameterType = (Optionals.withDefault (Syntax.TypeExpressionBasic Syntax.BasicTypeInt) (Syntax.variableDeclarationType p)), - Syntax.parameterName = (Syntax.variableDeclarationName p), - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing}) constructorParams), - Syntax.constructorDeclarationInitializers = (Lists.map (\field -> Syntax.MemInitializer { - Syntax.memInitializerName = (Syntax.variableDeclarationName field), - Syntax.memInitializerArguments = [ - createIdentifierExpr (Syntax.variableDeclarationName field)]}) cppFields), - Syntax.constructorDeclarationBody = (createConstructorBody constructorParams)}))]]))), - (createLessThanOperator name rt)])) - --- | Encode a Hydra type as a C++ type expression -encodeType :: t0 -> t1 -> Core.Type -> Either Errors.Error Syntax.TypeExpression -encodeType cx g typ = - - let t = Strip.deannotateType typ - in case t of - Core.TypeApplication v0 -> encodeApplicationType cx g v0 - Core.TypeEither v0 -> Eithers.bind (encodeType cx g (Core.eitherTypeLeft v0)) (\lt -> Eithers.bind (encodeType cx g (Core.eitherTypeRight v0)) (\rt -> Right (toConstType (createTemplateType "std::variant" [ - lt, - rt])))) - Core.TypeFunction v0 -> encodeFunctionType cx g v0 - Core.TypeForall v0 -> encodeForallType cx g v0 - Core.TypeList v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::vector" [ - enc])) (encodeType cx g v0) - Core.TypeMap v0 -> Eithers.bind (encodeType cx g (Core.mapTypeKeys v0)) (\kt -> Eithers.bind (encodeType cx g (Core.mapTypeValues v0)) (\vt -> Right (toConstType (createTemplateType "std::map" [ - kt, - vt])))) - Core.TypeLiteral v0 -> Right (encodeLiteralType v0) - Core.TypeOptional v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::optional" [ - enc])) (encodeType cx g v0) - Core.TypePair v0 -> Eithers.bind (encodeType cx g (Core.pairTypeFirst v0)) (\ft -> Eithers.bind (encodeType cx g (Core.pairTypeSecond v0)) (\st -> Right (toConstType (createTemplateType "std::pair" [ - ft, - st])))) - Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) - Core.TypeSet v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::set" [ - enc])) (encodeType cx g v0) - Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) - Core.TypeVariable v0 -> Right (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Core.unName v0)))) - Core.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrapped type")) - Core.TypeUnit -> Right (createTemplateType "std::tuple" []) - _ -> Left (Errors.ErrorOther (Errors.OtherError "Unsupported type")) - --- | Encode a type as a typedef / using declaration -encodeTypeAlias :: t0 -> t1 -> Core.Name -> Core.Type -> t2 -> Either Errors.Error Syntax.Declaration -encodeTypeAlias cx g name typ comment = - Eithers.bind (encodeType cx g typ) (\cppType -> Right (Syntax.DeclarationTypedef (Syntax.TypedefDeclaration { - Syntax.typedefDeclarationName = (className name), - Syntax.typedefDeclarationType = cppType, - Syntax.typedefDeclarationIsUsing = True}))) - --- | Encode a top-level type definition (dispatches to record/union/wrap) -encodeTypeDefinition :: t0 -> t1 -> Core.Name -> Core.Type -> Either Errors.Error [Syntax.Declaration] -encodeTypeDefinition cx g name typ = - - let t = Strip.deannotateType typ - in case t of - Core.TypeForall v0 -> encodeTypeDefinition cx g name (Core.forallTypeBody v0) - Core.TypeRecord v0 -> encodeRecordType cx g name v0 Nothing - Core.TypeUnion v0 -> encodeUnionType cx g name v0 Nothing - Core.TypeWrap v0 -> encodeWrappedType cx g name v0 Nothing - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "unexpected type in definition: " (PrintCore.type_ typ)))) - --- | Encode a union type (dispatches to enum or variant based on content) -encodeUnionType :: t0 -> t1 -> Core.Name -> [Core.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] -encodeUnionType cx g name rt comment = - Logic.ifElse (Predicates.isEnumRowType rt) (encodeEnumType cx g name rt comment) (encodeVariantType cx g name rt comment) - --- | Encode a variant (tagged union) type as a class hierarchy with visitor pattern -encodeVariantType :: t0 -> t1 -> Core.Name -> [Core.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] -encodeVariantType cx g name variants comment = - Eithers.bind (Eithers.mapList (\v -> createVariantClass cx g name name v) variants) (\variantClasses -> Right (Lists.concat [ - generateForwardDeclarations name variants, - [ - createVisitorInterface name variants], - [ - createUnionBaseClass name variants], - variantClasses, - [ - createPartialVisitorInterface name variants], - [ - createAcceptImplementation name variants]])) - --- | Encode a wrapped type as a single-field record -encodeWrappedType :: t0 -> t1 -> Core.Name -> Core.Type -> t2 -> Either Errors.Error [Syntax.Declaration] -encodeWrappedType cx g name typ comment = - encodeRecordType cx g name [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "value"), - Core.fieldTypeType = typ}] comment - --- | Find includes for a set of type definitions -findIncludes :: Bool -> Packaging.ModuleName -> [Packaging.TypeDefinition] -> [Syntax.IncludeDirective] -findIncludes withFwd ns defs = - Lists.concat [ - [ - Syntax.IncludeDirective { - Syntax.includeDirectiveName = "memory", - Syntax.includeDirectiveIsSystem = True}, - Syntax.IncludeDirective { - Syntax.includeDirectiveName = "stdexcept", - Syntax.includeDirectiveIsSystem = True}], - (Lists.map (\depName -> Syntax.IncludeDirective { - Syntax.includeDirectiveName = (bindingNameToFilePath depName), - Syntax.includeDirectiveIsSystem = False}) (findTypeDependencies ns defs)), - (Logic.ifElse withFwd [ - Syntax.IncludeDirective { - Syntax.includeDirectiveName = (bindingNameToFilePath (fwdHeaderName ns)), - Syntax.includeDirectiveIsSystem = False}] [])] - --- | Find type dependencies that are in other namespaces -findTypeDependencies :: Packaging.ModuleName -> [Packaging.TypeDefinition] -> [Core.Name] -findTypeDependencies ns defs = - Lists.filter (\n -> Logic.not (Equality.equal (Optionals.map Packaging.unModuleName (Names.moduleNameOf n)) (Just (Packaging.unModuleName ns)))) (Sets.toList (Lists.foldl (\acc -> \d -> Sets.union acc (Dependencies.typeDependencyNames True (Core.typeSchemeBody (Packaging.typeDefinitionBody d)))) Sets.empty defs)) - --- | Construct the forward-declaration header name for a namespace -fwdHeaderName :: Packaging.ModuleName -> Core.Name -fwdHeaderName ns = - Names.unqualifyName (Util.QualifiedName { - Util.qualifiedNameModuleName = (Just ns), - Util.qualifiedNameLocal = "Fwd"}) - --- | Gather metadata from definitions (simplified: always include common headers) -gatherMetadata :: t0 -> Bool -gatherMetadata defs = True - --- | Generate forward declarations for all variant subclasses -generateForwardDeclarations :: Core.Name -> [Core.FieldType] -> [Syntax.Declaration] -generateForwardDeclarations tname fields = - Lists.map (\ft -> cppClassDeclaration (variantName tname (Core.fieldTypeName ft)) [] Nothing) fields - --- | Generate a single type header file -generateTypeFile :: Packaging.ModuleName -> Packaging.TypeDefinition -> t0 -> t1 -> Either Errors.Error (String, String) -generateTypeFile ns def_ cx g = - - let name = Packaging.typeDefinitionName def_ - typ = Core.typeSchemeBody (Packaging.typeDefinitionBody def_) - in (Eithers.bind (encodeTypeDefinition cx g name typ) (\decls -> - let includes = findIncludes True ns [ - def_] - in (Right (serializeHeaderFile name includes [ - namespaceDecl ns decls])))) - --- | Generate all type header files for a module (fwd file + individual class files) -generateTypeFiles :: Packaging.ModuleName -> [Packaging.TypeDefinition] -> t0 -> t1 -> Either Errors.Error [(String, String)] -generateTypeFiles ns defs cx g = - Eithers.bind (Eithers.mapList (\d -> generateTypeFile ns d cx g) defs) (\classFiles -> Right classFiles) - --- | Check whether a type maps to an STL container type -isStdContainerType :: Core.Type -> Bool -isStdContainerType typ = - - let t = Strip.deannotateType typ - in case t of - Core.TypeApplication v0 -> isStdContainerType (Core.applicationTypeFunction v0) - Core.TypeList _ -> True - Core.TypeMap _ -> True - Core.TypeOptional _ -> True - Core.TypeSet _ -> True - _ -> False - --- | Check whether a type is a struct type (not a literal and not an enum) -isStructType :: Core.Type -> Bool -isStructType rawType = - - let t = Resolution.fullyStripType rawType - isLiteral = - case t of - Core.TypeLiteral _ -> True - _ -> False - in (Logic.and (Logic.not isLiteral) (Logic.not (Predicates.isEnumType rawType))) - --- | Check whether a type maps to a C++ template type (string or STL container) -isTemplateType :: Core.Type -> Bool -isTemplateType typ = - - let t = Strip.deannotateType typ - in (Logic.or (case t of - Core.TypeLiteral v0 -> case v0 of - Core.LiteralTypeString -> True - _ -> False - _ -> False) (isStdContainerType typ)) - --- | A protected access label -memberSpecificationProtected :: Syntax.MemberSpecification -memberSpecificationProtected = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierProtected - --- | A public access label -memberSpecificationPublic :: Syntax.MemberSpecification -memberSpecificationPublic = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierPublic - --- | Convert a module to C++ code files (entry point) -moduleToCpp :: Packaging.Module -> [Packaging.Definition] -> t0 -> t1 -> Either Errors.Error (M.Map String String) -moduleToCpp mod defs cx g = - - let ns = Packaging.moduleName mod - typeDefs = Pairs.first (Environment.partitionDefinitions defs) - in (Eithers.bind (generateTypeFiles ns typeDefs cx g) (\typeFiles -> Right (Maps.fromList typeFiles))) - --- | Create a namespace declaration wrapping declarations -namespaceDecl :: Packaging.ModuleName -> [Syntax.Declaration] -> Syntax.Declaration -namespaceDecl ns decls = - Syntax.DeclarationNamespace (Syntax.NamespaceDeclaration { - Syntax.namespaceDeclarationName = (encodeNamespace ns), - Syntax.namespaceDeclarationDeclarations = decls}) - --- | Construct a partial visitor interface name -partialVisitorName :: Core.Name -> String -partialVisitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "PartialVisitor") - --- | Sanitize a name to be valid in C++ -sanitizeCppName :: String -> String -sanitizeCppName name = Formatting.sanitizeWithUnderscores Language.cppReservedWords name - --- | Serialize a header file from name, includes, and declarations -serializeHeaderFile :: Core.Name -> [Syntax.IncludeDirective] -> [Syntax.Declaration] -> (String, String) -serializeHeaderFile name includes decls = - ( - bindingNameToFilePath name, - (Serialization.printExpr (Serialization.parenthesize (Serde.programToExpr (createHeaderFile includes decls))))) - --- | Wrap a type expression with a const qualifier -toConstType :: Syntax.TypeExpression -> Syntax.TypeExpression -toConstType baseType = - Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = baseType, - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst}) - --- | Create an unnamed parameter (for operator overloads, etc.) -unnamedParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter -unnamedParameter name typ = - Syntax.Parameter { - Syntax.parameterType = typ, - Syntax.parameterName = name, - Syntax.parameterUnnamed = True, - Syntax.parameterDefaultValue = Nothing} - --- | Construct a variant class name (e.g. "MyType" + "field" -> "MyTypeField") -variantName :: Core.Name -> Core.Name -> String -variantName tname fname = - sanitizeCppName (Strings.concat2 (Names.localNameOf tname) (Formatting.capitalize (Core.unName fname))) - --- | Construct a visitor interface name -visitorName :: Core.Name -> String -visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor") diff --git a/src/main/haskell/Hydra/Cpp/Environment.hs b/src/main/haskell/Hydra/Cpp/Environment.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Environment.hs +++ /dev/null @@ -1,28 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type definitions for C++ code generation environment - -module Hydra.Cpp.Environment where - -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Environment for C++ code generation -data CppEnvironment = - CppEnvironment { - -- | ModuleName mapping for code generation - cppEnvironmentNamespaces :: (Util.ModuleNames String), - -- | Type variables in scope, with their C++ names - cppEnvironmentBoundTypeVariables :: ([Core.Name], (M.Map Core.Name String))} - deriving (Eq, Ord, Read, Show) - -_CppEnvironment = Core.Name "hydra.cpp.environment.CppEnvironment" - -_CppEnvironment_namespaces = Core.Name "namespaces" - -_CppEnvironment_boundTypeVariables = Core.Name "boundTypeVariables" diff --git a/src/main/haskell/Hydra/Cpp/Language.hs b/src/main/haskell/Hydra/Cpp/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Language.hs +++ /dev/null @@ -1,275 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints and reserved words for C++ - -module Hydra.Cpp.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | Language constraints for C++ -cppLanguage :: Coders.Language -cppLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.cpp"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "cpp")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt8, - Core.IntegerTypeInt16, - Core.IntegerTypeInt32, - Core.IntegerTypeInt64, - Core.IntegerTypeBigint] - termVariants = - Sets.fromList [ - Variants.TermVariantApplication, - Variants.TermVariantEither, - Variants.TermVariantCases, - Variants.TermVariantLambda, - Variants.TermVariantProject, - Variants.TermVariantUnwrap, - Variants.TermVariantTypeApplication, - Variants.TermVariantTypeLambda, - Variants.TermVariantLet, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantPair, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantInject, - Variants.TermVariantVariable, - Variants.TermVariantWrap] - typeVariants = - Sets.fromList [ - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantFunction, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantVariable, - Variants.TypeVariantWrap] - typePredicate = \_ -> True - --- | A set of reserved words in C++ -cppReservedWords :: S.Set String -cppReservedWords = - Sets.fromList (Lists.concat [ - cppKeywords, - cppPreprocessor, - cppStlTypes, - hydraCppKeywords]) - where - cppKeywords = - [ - "alignas", - "alignof", - "and", - "and_eq", - "asm", - "auto", - "bitand", - "bitor", - "bool", - "break", - "case", - "catch", - "char", - "char8_t", - "char16_t", - "char32_t", - "class", - "compl", - "concept", - "const", - "consteval", - "constexpr", - "constinit", - "const_cast", - "continue", - "co_await", - "co_return", - "co_yield", - "decltype", - "default", - "delete", - "do", - "double", - "dynamic_cast", - "else", - "enum", - "explicit", - "export", - "extern", - "false", - "float", - "for", - "friend", - "goto", - "if", - "inline", - "int", - "long", - "mutable", - "namespace", - "new", - "noexcept", - "not", - "not_eq", - "nullptr", - "operator", - "or", - "or_eq", - "private", - "protected", - "public", - "register", - "reinterpret_cast", - "requires", - "return", - "short", - "signed", - "sizeof", - "static", - "static_assert", - "static_cast", - "struct", - "switch", - "template", - "this", - "thread_local", - "throw", - "true", - "try", - "typedef", - "typeid", - "typename", - "union", - "unsigned", - "using", - "virtual", - "void", - "volatile", - "wchar_t", - "while", - "xor", - "xor_eq"] - cppPreprocessor = - [ - "#define", - "#elif", - "#else", - "#endif", - "#error", - "#if", - "#ifdef", - "#ifndef", - "#include", - "#line", - "#pragma", - "#undef"] - cppStlTypes = - [ - "std", - "string", - "vector", - "map", - "set", - "optional", - "variant", - "pair", - "tuple", - "function", - "array", - "deque", - "forward_list", - "list", - "multimap", - "multiset", - "unordered_map", - "unordered_set", - "unordered_multimap", - "unordered_multiset", - "stack", - "queue", - "priority_queue", - "shared_ptr", - "unique_ptr", - "weak_ptr"] - hydraCppKeywords = [] diff --git a/src/main/haskell/Hydra/Cpp/Names.hs b/src/main/haskell/Hydra/Cpp/Names.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Names.hs +++ /dev/null @@ -1,148 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | C++ naming utilities: encoding Hydra names as C++ names - -module Hydra.Cpp.Names where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Cpp.Environment as Environment -import qualified Hydra.Cpp.Language as Language -import qualified Hydra.Cpp.Syntax as Syntax -import qualified Hydra.Cpp.Utils as Utils -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.Formatting as Formatting -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.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Get the C++ class name from a Hydra Name -className :: Core.Name -> String -className name = sanitizeCppName (Names.localNameOf name) - --- | Create a type reference, optionally wrapped in shared_ptr -createTypeReference :: Bool -> Environment.CppEnvironment -> Core.Name -> Syntax.TypeExpression -createTypeReference isPointer env name = - - let baseType = Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (encodeName True Util.CaseConventionPascal env name)) - in (Logic.ifElse isPointer (Utils.toConstType baseType) baseType) - --- | Encode an enum value with appropriate naming convention -encodeEnumValue :: Environment.CppEnvironment -> Core.Name -> String -encodeEnumValue = encodeName False Util.CaseConventionUpperSnake - --- | Encode a field name with appropriate naming convention -encodeFieldName :: Environment.CppEnvironment -> Core.Name -> String -encodeFieldName env fname = encodeName False Util.CaseConventionLowerSnake env fname - --- | Encode a name with specified convention -encodeName :: Bool -> Util.CaseConvention -> Environment.CppEnvironment -> Core.Name -> String -encodeName isQualified conv env name = - - let focusNs = Pairs.first (Util.moduleNamesFocus (Environment.cppEnvironmentNamespaces env)) - boundVars = Pairs.second (Environment.cppEnvironmentBoundTypeVariables env) - qualName = Names.qualifyName name - mns = Util.qualifiedNameModuleName qualName - local = Util.qualifiedNameLocal qualName - cppLocal = sanitizeCppName (Formatting.convertCase Util.CaseConventionCamel conv local) - cppNs = - \nsVal -> Strings.join "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal))) - in (Logic.ifElse isQualified (Optionals.match (Maps.lookup name boundVars) (Optionals.match mns cppLocal (\nsVal -> Strings.concat2 (cppNs nsVal) (Strings.concat2 "::" cppLocal))) (\n -> n)) cppLocal) - --- | Encode a qualified name with namespace -encodeNameQualified :: Environment.CppEnvironment -> Core.Name -> String -encodeNameQualified env name = - - let boundVars = Pairs.second (Environment.cppEnvironmentBoundTypeVariables env) - focusNs = Pairs.first (Util.moduleNamesFocus (Environment.cppEnvironmentNamespaces env)) - qualName = Names.qualifyName name - mns = Util.qualifiedNameModuleName qualName - local = Util.qualifiedNameLocal qualName - in (Optionals.match (Maps.lookup name boundVars) (Logic.ifElse (Equality.equal mns (Just focusNs)) (sanitizeCppName local) (Strings.join "::" (Lists.map sanitizeCppName (Strings.splitOn "." (Core.unName name))))) (\n -> n)) - --- | Encode a namespace as a C++ namespace string -encodeNamespace :: Packaging.ModuleName -> String -encodeNamespace nsVal = - Strings.join "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal))) - --- | Encode a type variable name -encodeTypeVariable :: Core.Name -> String -encodeTypeVariable name = Formatting.capitalize (Core.unName name) - --- | Get the forward header name for a namespace -fwdHeaderName :: Packaging.ModuleName -> Core.Name -fwdHeaderName nsVal = - Names.unqualifyName (Util.QualifiedName { - Util.qualifiedNameModuleName = (Just nsVal), - Util.qualifiedNameLocal = "Fwd"}) - --- | Create a namespace declaration wrapping inner declarations -namespaceDecl :: Packaging.ModuleName -> [Syntax.Declaration] -> Syntax.Declaration -namespaceDecl nsVal decls = - Syntax.DeclarationNamespace (Syntax.NamespaceDeclaration { - Syntax.namespaceDeclarationName = (encodeNamespace nsVal), - Syntax.namespaceDeclarationDeclarations = decls}) - --- | Get the partial visitor name for a type -partialVisitorName :: Core.Name -> String -partialVisitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "PartialVisitor") - --- | Sanitize a name to be valid in C++ -sanitizeCppName :: String -> String -sanitizeCppName = Formatting.sanitizeWithUnderscores Language.cppReservedWords - --- | Create a reference to a term variable -termVariableReference :: Environment.CppEnvironment -> Core.Name -> Syntax.Expression -termVariableReference = variableReference Util.CaseConventionLowerSnake - --- | Create a reference to a type variable -typeVariableReference :: Environment.CppEnvironment -> Core.Name -> Syntax.TypeExpression -typeVariableReference env name = - Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (encodeName True Util.CaseConventionPascal env name)) - --- | Create a variable reference expression -variableReference :: Util.CaseConvention -> Environment.CppEnvironment -> Core.Name -> Syntax.Expression -variableReference conv env name = Utils.createIdentifierExpr (encodeName True conv env name) - --- | Get the variant name by combining type name and field name -variantName :: Core.Name -> Core.Name -> String -variantName tname fname = - sanitizeCppName (Strings.concat2 (Names.localNameOf tname) (Formatting.capitalize (Core.unName fname))) - --- | Get the visitor name for a type -visitorName :: Core.Name -> String -visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor") diff --git a/src/main/haskell/Hydra/Cpp/Serde.hs b/src/main/haskell/Hydra/Cpp/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Serde.hs +++ /dev/null @@ -1,1354 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Serialization functions for converting C++ AST to abstract expressions - -module Hydra.Cpp.Serde where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Cpp.Syntax as Syntax -import qualified Hydra.Docs as Docs -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Convert an access specifier to an expression -accessSpecifierToExpr :: Syntax.AccessSpecifier -> Ast.Expr -accessSpecifierToExpr a = - case a of - Syntax.AccessSpecifierPublic -> Serialization.cst "public" - Syntax.AccessSpecifierProtected -> Serialization.cst "protected" - Syntax.AccessSpecifierPrivate -> Serialization.cst "private" - Syntax.AccessSpecifierNone -> Serialization.cst "" - --- | Convert an add operation to an expression -addOperationToExpr :: Syntax.AddOperation -> Ast.Expr -addOperationToExpr op = - - let left = Syntax.addOperationLeft op - right = Syntax.addOperationRight op - in (Serialization.spaceSep [ - additiveExpressionToExpr left, - (Serialization.cst "+"), - (multiplicativeExpressionToExpr right)]) - --- | Convert an additive expression to an expression -additiveExpressionToExpr :: Syntax.AdditiveExpression -> Ast.Expr -additiveExpressionToExpr e = - case e of - Syntax.AdditiveExpressionMultiplicative v0 -> multiplicativeExpressionToExpr v0 - Syntax.AdditiveExpressionAdd v0 -> addOperationToExpr v0 - Syntax.AdditiveExpressionSubtract v0 -> subtractOperationToExpr v0 - --- | Convert an and expression to an expression -andExpressionToExpr :: Syntax.AndExpression -> Ast.Expr -andExpressionToExpr e = - case e of - Syntax.AndExpressionEquality v0 -> equalityExpressionToExpr v0 - Syntax.AndExpressionBitwiseAnd v0 -> bitwiseAndOperationToExpr v0 - --- | Convert an assignment expression to an expression -assignmentExpressionToExpr :: Syntax.AssignmentExpression -> Ast.Expr -assignmentExpressionToExpr a = - case a of - Syntax.AssignmentExpressionConditional v0 -> conditionalExpressionToExpr v0 - Syntax.AssignmentExpressionAssignment v0 -> explicitAssignmentToExpr v0 - --- | Convert an assignment operator to an expression -assignmentOperatorToExpr :: Syntax.AssignmentOperator -> Ast.Expr -assignmentOperatorToExpr op = - case op of - Syntax.AssignmentOperatorAssign -> Serialization.cst "=" - Syntax.AssignmentOperatorPlusAssign -> Serialization.cst "+=" - Syntax.AssignmentOperatorMinusAssign -> Serialization.cst "-=" - Syntax.AssignmentOperatorMultiplyAssign -> Serialization.cst "*=" - Syntax.AssignmentOperatorDivideAssign -> Serialization.cst "/=" - Syntax.AssignmentOperatorModuloAssign -> Serialization.cst "%=" - Syntax.AssignmentOperatorLeftShiftAssign -> Serialization.cst "<<=" - Syntax.AssignmentOperatorRightShiftAssign -> Serialization.cst ">>=" - Syntax.AssignmentOperatorBitwiseAndAssign -> Serialization.cst "&=" - Syntax.AssignmentOperatorBitwiseXorAssign -> Serialization.cst "^=" - Syntax.AssignmentOperatorBitwiseOrAssign -> Serialization.cst "|=" - --- | Convert a base specifier to an expression -baseSpecifierToExpr :: Syntax.BaseSpecifier -> Ast.Expr -baseSpecifierToExpr bs = - - let access = Syntax.baseSpecifierAccess bs - name = Syntax.baseSpecifierName bs - in (Serialization.spaceSep [ - accessSpecifierToExpr access, - (Serialization.cst name)]) - --- | Convert a basic type to an expression -basicTypeToExpr :: Syntax.BasicType -> Ast.Expr -basicTypeToExpr t = - case t of - Syntax.BasicTypeVoid -> Serialization.cst "void" - Syntax.BasicTypeBool -> Serialization.cst "bool" - Syntax.BasicTypeChar -> Serialization.cst "char" - Syntax.BasicTypeInt -> Serialization.cst "int" - Syntax.BasicTypeFloat -> Serialization.cst "float" - Syntax.BasicTypeDouble -> Serialization.cst "double" - Syntax.BasicTypeString -> Serialization.cst "std::string" - Syntax.BasicTypeAuto -> Serialization.cst "auto" - Syntax.BasicTypeNamed v0 -> Serialization.cst v0 - --- | Convert a bitwise and operation to an expression -bitwiseAndOperationToExpr :: Syntax.BitwiseAndOperation -> Ast.Expr -bitwiseAndOperationToExpr op = - - let left = Syntax.bitwiseAndOperationLeft op - right = Syntax.bitwiseAndOperationRight op - in (Serialization.spaceSep [ - andExpressionToExpr left, - (Serialization.cst "&"), - (equalityExpressionToExpr right)]) - --- | Convert a bitwise or operation to an expression -bitwiseOrOperationToExpr :: Syntax.BitwiseOrOperation -> Ast.Expr -bitwiseOrOperationToExpr op = - - let left = Syntax.bitwiseOrOperationLeft op - right = Syntax.bitwiseOrOperationRight op - in (Serialization.spaceSep [ - inclusiveOrExpressionToExpr left, - (Serialization.cst "|"), - (exclusiveOrExpressionToExpr right)]) - --- | Convert a bitwise xor operation to an expression -bitwiseXorOperationToExpr :: Syntax.BitwiseXorOperation -> Ast.Expr -bitwiseXorOperationToExpr op = - - let left = Syntax.bitwiseXorOperationLeft op - right = Syntax.bitwiseXorOperationRight op - in (Serialization.spaceSep [ - exclusiveOrExpressionToExpr left, - (Serialization.cst "^"), - (andExpressionToExpr right)]) - --- | Convert a boolean literal to an expression -booleanLiteralToExpr :: Syntax.BooleanLiteral -> Ast.Expr -booleanLiteralToExpr bl = Logic.ifElse (Syntax.unBooleanLiteral bl) (Serialization.cst "true") (Serialization.cst "false") - --- | Convert a capture list to an expression -captureListToExpr :: Syntax.CaptureList -> Ast.Expr -captureListToExpr cl = - case cl of - Syntax.CaptureListCaptureByValue -> Serialization.cst "[=]" - Syntax.CaptureListCaptures v0 -> Serialization.bracketList Serialization.inlineStyle (Lists.map captureToExpr v0) - --- | Convert a capture to an expression -captureToExpr :: Syntax.Capture -> Ast.Expr -captureToExpr cap = - - let name = Syntax.captureName cap - byRef = Syntax.captureByReference cap - in (Logic.ifElse byRef (Serialization.cst (Strings.concat2 "&" name)) (Serialization.cst name)) - --- | Convert a case statement to an expression -caseStatementToExpr :: Syntax.CaseStatement -> Ast.Expr -caseStatementToExpr stmt = - case stmt of - Syntax.CaseStatementCase v0 -> caseValueToExpr v0 - Syntax.CaseStatementDefault v0 -> Serialization.spaceSep [ - Serialization.cst "default:", - (statementToExpr v0)] - --- | Convert a case value to an expression -caseValueToExpr :: Syntax.CaseValue -> Ast.Expr -caseValueToExpr cv = - - let value = Syntax.caseValueValue cv - statement = Syntax.caseValueStatement cv - in (Serialization.spaceSep [ - Serialization.cst "case", - (Serialization.noSep [ - expressionToExpr value, - (Serialization.cst ":")]), - (statementToExpr statement)]) - --- | Convert a class body to an expression -classBodyToExpr :: Bool -> Syntax.ClassBody -> Ast.Expr -classBodyToExpr commas cb = - Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map (memberSpecificationToExpr commas) (Syntax.unClassBody cb))) - --- | Convert a class declaration to an expression -classDeclarationToExpr :: Syntax.ClassDeclaration -> Ast.Expr -classDeclarationToExpr cd = - - let spec = Syntax.classDeclarationSpecifier cd - mbody = Syntax.classDeclarationBody cd - key = Syntax.classSpecifierKey spec - isEnum = Logic.or (Equality.equal key Syntax.ClassKeyEnum) (Equality.equal key Syntax.ClassKeyEnumClass) - in (Serialization.withSemi (Serialization.spaceSep (Optionals.givens [ - Just (classSpecifierToExpr spec), - (Optionals.map (\body -> classBodyToExpr isEnum body) mbody)]))) - --- | Convert a class key to an expression -classKeyToExpr :: Syntax.ClassKey -> Ast.Expr -classKeyToExpr k = - case k of - Syntax.ClassKeyClass -> Serialization.cst "class" - Syntax.ClassKeyEnum -> Serialization.cst "enum" - Syntax.ClassKeyEnumClass -> Serialization.cst "enum class" - Syntax.ClassKeyStruct -> Serialization.cst "struct" - --- | Convert a class specifier to an expression -classSpecifierToExpr :: Syntax.ClassSpecifier -> Ast.Expr -classSpecifierToExpr cs = - - let key = Syntax.classSpecifierKey cs - name = Syntax.classSpecifierName cs - inheritance = Syntax.classSpecifierInheritance cs - in (Serialization.spaceSep (Lists.concat [ - [ - classKeyToExpr key, - (Serialization.cst name)], - (Logic.ifElse (Lists.isEmpty inheritance) [] [ - Serialization.cst ":", - (Serialization.commaSep Serialization.inlineStyle (Lists.map baseSpecifierToExpr inheritance))])])) - --- | Convert a comma expression to an expression -commaExpressionToExpr :: Syntax.CommaExpression -> Ast.Expr -commaExpressionToExpr ce = - - let left = Syntax.commaExpressionLeft ce - right = Syntax.commaExpressionRight ce - in (Serialization.spaceSep [ - expressionToExpr left, - (Serialization.cst ","), - (assignmentExpressionToExpr right)]) - --- | Convert a comment to an expression -commentToExpr :: Syntax.Comment -> Ast.Expr -commentToExpr c = - - let text = Syntax.commentText c - isMultiline = Syntax.commentIsMultiline c - in (Serialization.cst (toCppComments text isMultiline)) - --- | Convert a compound statement to an expression -compoundStatementToExpr :: Syntax.CompoundStatement -> Ast.Expr -compoundStatementToExpr cs = - Serialization.curlyBracesList (Just "") Serialization.fullBlockStyle (Lists.map statementToExpr (Syntax.unCompoundStatement cs)) - --- | Convert a conditional expression to an expression -conditionalExpressionToExpr :: Syntax.ConditionalExpression -> Ast.Expr -conditionalExpressionToExpr c = - case c of - Syntax.ConditionalExpressionLogicalOr v0 -> logicalOrExpressionToExpr v0 - Syntax.ConditionalExpressionTernary v0 -> ternaryExpressionToExpr v0 - --- | Convert a constructor declaration to an expression -constructorDeclarationToExpr :: Syntax.ConstructorDeclaration -> Ast.Expr -constructorDeclarationToExpr cd = - - let name = Syntax.constructorDeclarationName cd - params = Syntax.constructorDeclarationParameters cd - inits = Syntax.constructorDeclarationInitializers cd - body = Syntax.constructorDeclarationBody cd - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.noSep [ - Serialization.cst name, - (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]), - (Logic.ifElse (Lists.isEmpty inits) Nothing (Just (Serialization.spaceSep [ - Serialization.cst ":", - (Serialization.commaSep Serialization.inlineStyle (Lists.map memInitializerToExpr inits))]))), - (Just (functionBodyToExpr body))])) - --- | Convert a declaration to an expression -declarationToExpr :: Syntax.Declaration -> Ast.Expr -declarationToExpr d = - case d of - Syntax.DeclarationPreprocessor v0 -> preprocessorDirectiveToExpr v0 - Syntax.DeclarationClass v0 -> classDeclarationToExpr v0 - Syntax.DeclarationFunction v0 -> functionDeclarationToExpr v0 - Syntax.DeclarationVariable v0 -> variableDeclarationToExpr False v0 - Syntax.DeclarationTypedef v0 -> typedefDeclarationToExpr v0 - Syntax.DeclarationNamespace v0 -> namespaceDeclarationToExpr v0 - Syntax.DeclarationTemplate v0 -> templateDeclarationToExpr v0 - --- | Convert a define directive to an expression -defineDirectiveToExpr :: Syntax.DefineDirective -> Ast.Expr -defineDirectiveToExpr dd = - - let name = Syntax.defineDirectiveName dd - params = Syntax.defineDirectiveParameters dd - replacement = Syntax.defineDirectiveReplacement dd - in (Serialization.spaceSep (Lists.concat [ - [ - Serialization.cst "#define", - (Serialization.cst name)], - (Optionals.match params [] (\ps -> [ - Serialization.parenListAdaptive (Lists.map (\p -> Serialization.cst p) ps)])), - (Optionals.match replacement [] (\r -> [ - Serialization.cst r]))])) - --- | Convert a destructor declaration to an expression -destructorDeclarationToExpr :: Syntax.DestructorDeclaration -> Ast.Expr -destructorDeclarationToExpr dd = - - let prefixSpecs = Syntax.destructorDeclarationPrefixSpecifiers dd - name = Syntax.destructorDeclarationName dd - suffixSpecs = Syntax.destructorDeclarationSuffixSpecifiers dd - body = Syntax.destructorDeclarationBody dd - in (Serialization.spaceSep (Lists.concat [ - Lists.map functionSpecifierPrefixToExpr prefixSpecs, - [ - Serialization.noSep [ - Serialization.cst (Strings.concat2 "~" name), - (Serialization.parens (Serialization.cst ""))]], - (Lists.map functionSpecifierSuffixToExpr suffixSpecs), - [ - functionBodyToExpr body]])) - --- | Convert a divide operation to an expression -divideOperationToExpr :: Syntax.DivideOperation -> Ast.Expr -divideOperationToExpr op = - - let left = Syntax.divideOperationLeft op - right = Syntax.divideOperationRight op - in (Serialization.spaceSep [ - multiplicativeExpressionToExpr left, - (Serialization.cst "/"), - (unaryExpressionToExpr right)]) - --- | Convert a do statement to an expression -doStatementToExpr :: Syntax.DoStatement -> Ast.Expr -doStatementToExpr ds = - - let body = Syntax.doStatementBody ds - cond = Syntax.doStatementCondition ds - in (Serialization.newlineSep [ - Serialization.cst "do", - (statementToExpr body), - (Serialization.withSemi (Serialization.spaceSep [ - Serialization.cst "while", - (Serialization.parens (expressionToExpr cond))]))]) - --- | Convert an elif directive to an expression -elifDirectiveToExpr :: Syntax.ElifDirective -> Ast.Expr -elifDirectiveToExpr ed = - Serialization.spaceSep [ - Serialization.cst "#elif", - (Serialization.cst (Syntax.elifDirectiveCondition ed))] - --- | Convert an else directive to an expression -elseDirectiveToExpr :: t0 -> Ast.Expr -elseDirectiveToExpr ed = Serialization.cst "#else" - --- | Convert an endif directive to an expression -endifDirectiveToExpr :: t0 -> Ast.Expr -endifDirectiveToExpr ed = Serialization.cst "#endif" - --- | Convert an equal operation to an expression -equalOperationToExpr :: Syntax.EqualOperation -> Ast.Expr -equalOperationToExpr op = - - let left = Syntax.equalOperationLeft op - right = Syntax.equalOperationRight op - in (Serialization.spaceSep [ - equalityExpressionToExpr left, - (Serialization.cst "=="), - (relationalExpressionToExpr right)]) - --- | Convert an equality expression to an expression -equalityExpressionToExpr :: Syntax.EqualityExpression -> Ast.Expr -equalityExpressionToExpr e = - case e of - Syntax.EqualityExpressionRelational v0 -> relationalExpressionToExpr v0 - Syntax.EqualityExpressionEqual v0 -> equalOperationToExpr v0 - Syntax.EqualityExpressionNotEqual v0 -> notEqualOperationToExpr v0 - --- | Convert an error directive to an expression -errorDirectiveToExpr :: Syntax.ErrorDirective -> Ast.Expr -errorDirectiveToExpr ed = - Serialization.spaceSep [ - Serialization.cst "#error", - (Serialization.cst (Syntax.errorDirectiveMessage ed))] - --- | Convert an exclusive or expression to an expression -exclusiveOrExpressionToExpr :: Syntax.ExclusiveOrExpression -> Ast.Expr -exclusiveOrExpressionToExpr e = - case e of - Syntax.ExclusiveOrExpressionAnd v0 -> andExpressionToExpr v0 - Syntax.ExclusiveOrExpressionBitwiseXor v0 -> bitwiseXorOperationToExpr v0 - --- | Convert an explicit assignment to an expression -explicitAssignmentToExpr :: Syntax.ExplicitAssignment -> Ast.Expr -explicitAssignmentToExpr ea = - - let left = Syntax.explicitAssignmentLeft ea - op = Syntax.explicitAssignmentOp ea - right = Syntax.explicitAssignmentRight ea - in (Serialization.spaceSep [ - logicalOrExpressionToExpr left, - (assignmentOperatorToExpr op), - (assignmentExpressionToExpr right)]) - --- | Convert an expression to an expression -expressionToExpr :: Syntax.Expression -> Ast.Expr -expressionToExpr e = - case e of - Syntax.ExpressionAssignment v0 -> assignmentExpressionToExpr v0 - Syntax.ExpressionComma v0 -> commaExpressionToExpr v0 - --- | Convert a for-init to an expression -forInitToExpr :: Syntax.ForInit -> Ast.Expr -forInitToExpr i = - case i of - Syntax.ForInitExpression v0 -> expressionToExpr v0 - Syntax.ForInitDeclaration v0 -> variableDeclarationToExpr False v0 - Syntax.ForInitEmpty -> Serialization.cst "" - --- | Convert a for statement to an expression -forStatementToExpr :: Syntax.ForStatement -> Ast.Expr -forStatementToExpr fs = - - let init = Syntax.forStatementInit fs - cond = Syntax.forStatementCondition fs - inc = Syntax.forStatementIncrement fs - body = Syntax.forStatementBody fs - in (Serialization.newlineSep [ - Serialization.spaceSep [ - Serialization.cst "for", - (Serialization.parens (Serialization.noSep [ - forInitToExpr init, - (Serialization.cst ";"), - (expressionToExpr cond), - (Serialization.cst ";"), - (expressionToExpr inc)]))], - (statementToExpr body)]) - --- | Convert a function application to an expression -functionApplicationToExpr :: Syntax.FunctionApplication -> Ast.Expr -functionApplicationToExpr fa = - - let func = Syntax.functionApplicationFunction fa - args = Syntax.functionApplicationArguments fa - in (Serialization.spaceSep [ - functionIdentifierToExpr func, - (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) - --- | Convert a function body to an expression -functionBodyToExpr :: Syntax.FunctionBody -> Ast.Expr -functionBodyToExpr b = - case b of - Syntax.FunctionBodyCompound v0 -> compoundStatementToExpr v0 - Syntax.FunctionBodyDeclaration -> Serialization.cst ";" - Syntax.FunctionBodyPure -> Serialization.withSemi (Serialization.cst "= 0") - Syntax.FunctionBodyDefault -> Serialization.withSemi (Serialization.cst "= default") - --- | Convert a function call operation to an expression -functionCallOperationToExpr :: Syntax.FunctionCallOperation -> Ast.Expr -functionCallOperationToExpr fco = - - let func = Syntax.functionCallOperationFunction fco - args = Syntax.functionCallOperationArguments fco - in (Serialization.noSep [ - postfixExpressionToExpr func, - (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) - --- | Convert a function declaration to an expression -functionDeclarationToExpr :: Syntax.FunctionDeclaration -> Ast.Expr -functionDeclarationToExpr fd = - - let prefixSpecs = Syntax.functionDeclarationPrefixSpecifiers fd - retType = Syntax.functionDeclarationReturnType fd - name = Syntax.functionDeclarationName fd - params = Syntax.functionDeclarationParameters fd - suffixSpecs = Syntax.functionDeclarationSuffixSpecifiers fd - body = Syntax.functionDeclarationBody fd - in (Serialization.spaceSep (Lists.concat [ - Lists.map functionSpecifierPrefixToExpr prefixSpecs, - [ - typeExpressionToExpr retType, - (Serialization.noSep [ - Serialization.cst name, - (Serialization.parenListAdaptive (Lists.map parameterToExpr params))])], - (Lists.map functionSpecifierSuffixToExpr suffixSpecs), - [ - functionBodyToExpr body]])) - --- | Convert a function identifier to an expression -functionIdentifierToExpr :: Syntax.FunctionIdentifier -> Ast.Expr -functionIdentifierToExpr f = - case f of - Syntax.FunctionIdentifierSimple v0 -> Serialization.cst v0 - Syntax.FunctionIdentifierQualified v0 -> qualifiedIdentifierToExpr v0 - --- | Convert a function specifier prefix to an expression -functionSpecifierPrefixToExpr :: Syntax.FunctionSpecifierPrefix -> Ast.Expr -functionSpecifierPrefixToExpr s = - case s of - Syntax.FunctionSpecifierPrefixInline -> Serialization.cst "inline" - Syntax.FunctionSpecifierPrefixVirtual -> Serialization.cst "virtual" - Syntax.FunctionSpecifierPrefixStatic -> Serialization.cst "static" - Syntax.FunctionSpecifierPrefixExplicit -> Serialization.cst "explicit" - --- | Convert a function specifier suffix to an expression -functionSpecifierSuffixToExpr :: Syntax.FunctionSpecifierSuffix -> Ast.Expr -functionSpecifierSuffixToExpr s = - case s of - Syntax.FunctionSpecifierSuffixConst -> Serialization.cst "const" - Syntax.FunctionSpecifierSuffixNoexcept -> Serialization.cst "noexcept" - Syntax.FunctionSpecifierSuffixOverride -> Serialization.cst "override" - Syntax.FunctionSpecifierSuffixFinal -> Serialization.cst "final" - --- | Convert a function type to an expression -functionTypeToExpr :: Syntax.FunctionType -> Ast.Expr -functionTypeToExpr ft = - - let retType = Syntax.functionTypeReturnType ft - params = Syntax.functionTypeParameters ft - in (Serialization.spaceSep [ - typeExpressionToExpr retType, - (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]) - --- | Convert a greater-than-or-equal operation to an expression -greaterEqualOperationToExpr :: Syntax.GreaterEqualOperation -> Ast.Expr -greaterEqualOperationToExpr op = - - let left = Syntax.greaterEqualOperationLeft op - right = Syntax.greaterEqualOperationRight op - in (Serialization.spaceSep [ - relationalExpressionToExpr left, - (Serialization.cst ">="), - (shiftExpressionToExpr right)]) - --- | Convert a greater-than operation to an expression -greaterOperationToExpr :: Syntax.GreaterOperation -> Ast.Expr -greaterOperationToExpr op = - - let left = Syntax.greaterOperationLeft op - right = Syntax.greaterOperationRight op - in (Serialization.spaceSep [ - relationalExpressionToExpr left, - (Serialization.cst ">"), - (shiftExpressionToExpr right)]) - --- | Convert an if directive to an expression -ifDirectiveToExpr :: Syntax.IfDirective -> Ast.Expr -ifDirectiveToExpr ifd = - Serialization.spaceSep [ - Serialization.cst "#if", - (Serialization.cst (Syntax.ifDirectiveCondition ifd))] - --- | Convert an ifdef directive to an expression -ifdefDirectiveToExpr :: Syntax.IfdefDirective -> Ast.Expr -ifdefDirectiveToExpr id = - Serialization.spaceSep [ - Serialization.cst "#ifdef", - (Serialization.cst (Syntax.ifdefDirectiveIdentifier id))] - --- | Convert an ifndef directive to an expression -ifndefDirectiveToExpr :: Syntax.IfndefDirective -> Ast.Expr -ifndefDirectiveToExpr ind = - Serialization.spaceSep [ - Serialization.cst "#ifndef", - (Serialization.cst (Syntax.ifndefDirectiveIdentifier ind))] - --- | Convert an include directive to an expression -includeDirectiveToExpr :: Syntax.IncludeDirective -> Ast.Expr -includeDirectiveToExpr incl = - - let name = Syntax.includeDirectiveName incl - isSystem = Syntax.includeDirectiveIsSystem incl - in (Logic.ifElse isSystem (Serialization.cst (Strings.concat [ - "#include <", - name, - ">"])) (Serialization.cst (Strings.concat [ - "#include \"", - name, - "\""]))) - --- | Convert an inclusive or expression to an expression -inclusiveOrExpressionToExpr :: Syntax.InclusiveOrExpression -> Ast.Expr -inclusiveOrExpressionToExpr e = - case e of - Syntax.InclusiveOrExpressionExclusiveOr v0 -> exclusiveOrExpressionToExpr v0 - Syntax.InclusiveOrExpressionBitwiseOr v0 -> bitwiseOrOperationToExpr v0 - --- | Convert an integer literal to an expression -integerLiteralToExpr :: Syntax.IntegerLiteral -> Ast.Expr -integerLiteralToExpr i = - case i of - Syntax.IntegerLiteralDecimal v0 -> Serialization.cst (Literals.printBigint v0) - Syntax.IntegerLiteralHexadecimal v0 -> Serialization.cst (Strings.concat2 "0x" v0) - Syntax.IntegerLiteralOctal v0 -> Serialization.cst (Strings.concat2 "0" v0) - Syntax.IntegerLiteralBinary v0 -> Serialization.cst (Strings.concat2 "0b" v0) - --- | Convert an iteration statement to an expression -iterationStatementToExpr :: Syntax.IterationStatement -> Ast.Expr -iterationStatementToExpr i = - case i of - Syntax.IterationStatementWhile v0 -> whileStatementToExpr v0 - Syntax.IterationStatementDo v0 -> doStatementToExpr v0 - Syntax.IterationStatementFor v0 -> forStatementToExpr v0 - Syntax.IterationStatementRangeFor v0 -> rangeForStatementToExpr v0 - --- | Convert a jump statement to an expression -jumpStatementToExpr :: Syntax.JumpStatement -> Ast.Expr -jumpStatementToExpr j = - case j of - Syntax.JumpStatementBreak -> Serialization.withSemi (Serialization.cst "break") - Syntax.JumpStatementContinue -> Serialization.withSemi (Serialization.cst "continue") - Syntax.JumpStatementReturnValue v0 -> Serialization.withSemi (Serialization.spaceSep [ - Serialization.cst "return", - (expressionToExpr v0)]) - Syntax.JumpStatementReturnVoid -> Serialization.withSemi (Serialization.cst "return") - Syntax.JumpStatementThrow v0 -> Serialization.withSemi (Serialization.spaceSep [ - Serialization.cst "throw", - (expressionToExpr v0)]) - --- | Convert a labeled statement to an expression -labeledStatementToExpr :: Syntax.LabeledStatement -> Ast.Expr -labeledStatementToExpr ls = - - let label = Syntax.labeledStatementLabel ls - stmt = Syntax.labeledStatementStatement ls - in (Serialization.newlineSep [ - Serialization.cst (Strings.concat2 label ":"), - (statementToExpr stmt)]) - --- | Convert a lambda expression to an expression -lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr -lambdaExpressionToExpr le = - - let captures = Syntax.lambdaExpressionCaptures le - params = Syntax.lambdaExpressionParameters le - retType = Syntax.lambdaExpressionReturnType le - body = Syntax.lambdaExpressionBody le - in (Serialization.spaceSep [ - captureListToExpr captures, - (Logic.ifElse (Lists.isEmpty params) (Serialization.parens (Serialization.cst "")) (Serialization.parenListAdaptive (Lists.map parameterToExpr params))), - (Optionals.match retType (Serialization.cst "") (\t -> Serialization.spaceSep [ - Serialization.cst "->", - (typeExpressionToExpr t)])), - (compoundStatementToExpr body)]) - --- | Convert a left shift operation to an expression -leftShiftOperationToExpr :: Syntax.LeftShiftOperation -> Ast.Expr -leftShiftOperationToExpr op = - - let left = Syntax.leftShiftOperationLeft op - right = Syntax.leftShiftOperationRight op - in (Serialization.spaceSep [ - shiftExpressionToExpr left, - (Serialization.cst "<<"), - (additiveExpressionToExpr right)]) - --- | Convert a less-than-or-equal operation to an expression -lessEqualOperationToExpr :: Syntax.LessEqualOperation -> Ast.Expr -lessEqualOperationToExpr op = - - let left = Syntax.lessEqualOperationLeft op - right = Syntax.lessEqualOperationRight op - in (Serialization.spaceSep [ - relationalExpressionToExpr left, - (Serialization.cst "<="), - (shiftExpressionToExpr right)]) - --- | Convert a less-than operation to an expression -lessOperationToExpr :: Syntax.LessOperation -> Ast.Expr -lessOperationToExpr op = - - let left = Syntax.lessOperationLeft op - right = Syntax.lessOperationRight op - in (Serialization.spaceSep [ - relationalExpressionToExpr left, - (Serialization.cst "<"), - (shiftExpressionToExpr right)]) - --- | Convert a line directive to an expression -lineDirectiveToExpr :: Syntax.LineDirective -> Ast.Expr -lineDirectiveToExpr ld = - - let lineNumber = Syntax.lineDirectiveLineNumber ld - filename = Syntax.lineDirectiveFilename ld - in (Serialization.spaceSep (Lists.concat [ - [ - Serialization.cst "#line", - (Serialization.cst (Literals.printInt32 lineNumber))], - (Optionals.match filename [] (\f -> [ - Serialization.cst (Strings.concat [ - "\"", - f, - "\""])]))])) - --- | Convert a literal to an expression -literalToExpr :: Syntax.Literal -> Ast.Expr -literalToExpr l = - case l of - Syntax.LiteralInteger v0 -> integerLiteralToExpr v0 - Syntax.LiteralFloating v0 -> Serialization.cst (Literals.printFloat64 (Syntax.unFloatingLiteral v0)) - Syntax.LiteralCharacter v0 -> Serialization.cst (Strings.concat [ - "'", - (Syntax.unCharacterLiteral v0), - "'"]) - Syntax.LiteralString v0 -> Serialization.cst (Strings.concat [ - "\"", - (Syntax.unStringLiteral v0), - "\""]) - Syntax.LiteralBoolean v0 -> booleanLiteralToExpr v0 - Syntax.LiteralNull -> Serialization.cst "nullptr" - --- | Convert a logical and expression to an expression -logicalAndExpressionToExpr :: Syntax.LogicalAndExpression -> Ast.Expr -logicalAndExpressionToExpr e = - case e of - Syntax.LogicalAndExpressionInclusiveOr v0 -> inclusiveOrExpressionToExpr v0 - Syntax.LogicalAndExpressionLogicalAnd v0 -> logicalAndOperationToExpr v0 - --- | Convert a logical and operation to an expression -logicalAndOperationToExpr :: Syntax.LogicalAndOperation -> Ast.Expr -logicalAndOperationToExpr op = - - let left = Syntax.logicalAndOperationLeft op - right = Syntax.logicalAndOperationRight op - in (Serialization.spaceSep [ - logicalAndExpressionToExpr left, - (Serialization.cst "&&"), - (inclusiveOrExpressionToExpr right)]) - --- | Convert a logical or expression to an expression -logicalOrExpressionToExpr :: Syntax.LogicalOrExpression -> Ast.Expr -logicalOrExpressionToExpr e = - case e of - Syntax.LogicalOrExpressionLogicalAnd v0 -> logicalAndExpressionToExpr v0 - Syntax.LogicalOrExpressionLogicalOr v0 -> logicalOrOperationToExpr v0 - --- | Convert a logical or operation to an expression -logicalOrOperationToExpr :: Syntax.LogicalOrOperation -> Ast.Expr -logicalOrOperationToExpr op = - - let left = Syntax.logicalOrOperationLeft op - right = Syntax.logicalOrOperationRight op - in (Serialization.spaceSep [ - logicalOrExpressionToExpr left, - (Serialization.cst "||"), - (logicalAndExpressionToExpr right)]) - --- | Convert a map entry to an expression -mapEntryToExpr :: Syntax.MapEntry -> Ast.Expr -mapEntryToExpr me = - - let key = Syntax.mapEntryKey me - val = Syntax.mapEntryValue me - in (Serialization.spaceSep [ - Serialization.curlyBracesList Nothing Serialization.inlineStyle [ - expressionToExpr key], - (Serialization.cst "->"), - (expressionToExpr val)]) - --- | Convert a map to an expression -mapToExpr :: Syntax.Map -> Ast.Expr -mapToExpr m = - - let keyType = Syntax.mapKeyType m - valType = Syntax.mapValueType m - entries = Syntax.mapEntries m - in (Serialization.spaceSep [ - Serialization.cst "std::map<", - (Serialization.commaSep Serialization.inlineStyle [ - typeExpressionToExpr keyType, - (typeExpressionToExpr valType)]), - (Serialization.cst ">"), - (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map mapEntryToExpr entries))]) - --- | Convert a member initializer to an expression -memInitializerToExpr :: Syntax.MemInitializer -> Ast.Expr -memInitializerToExpr mi = - - let name = Syntax.memInitializerName mi - args = Syntax.memInitializerArguments mi - in (Serialization.noSep [ - Serialization.cst name, - (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) - --- | Convert a member access operation to an expression -memberAccessOperationToExpr :: Syntax.MemberAccessOperation -> Ast.Expr -memberAccessOperationToExpr mao = - - let obj = Syntax.memberAccessOperationObject mao - member = Syntax.memberAccessOperationMember mao - in (Serialization.noSep [ - postfixExpressionToExpr obj, - (Serialization.cst "."), - (Serialization.cst member)]) - --- | Convert a member declaration to an expression -memberDeclarationToExpr :: Bool -> Syntax.MemberDeclaration -> Ast.Expr -memberDeclarationToExpr commas m = - case m of - Syntax.MemberDeclarationFunction v0 -> functionDeclarationToExpr v0 - Syntax.MemberDeclarationVariable v0 -> variableDeclarationToExpr commas v0 - Syntax.MemberDeclarationConstructor v0 -> constructorDeclarationToExpr v0 - Syntax.MemberDeclarationDestructor v0 -> destructorDeclarationToExpr v0 - Syntax.MemberDeclarationNestedClass v0 -> classDeclarationToExpr v0 - Syntax.MemberDeclarationTemplate v0 -> templateDeclarationToExpr v0 - --- | Convert a member specification to an expression -memberSpecificationToExpr :: Bool -> Syntax.MemberSpecification -> Ast.Expr -memberSpecificationToExpr commas m = - case m of - Syntax.MemberSpecificationAccessLabel v0 -> Serialization.noSep [ - accessSpecifierToExpr v0, - (Serialization.cst ":")] - Syntax.MemberSpecificationMember v0 -> memberDeclarationToExpr commas v0 - --- | Convert a modulo operation to an expression -moduloOperationToExpr :: Syntax.ModuloOperation -> Ast.Expr -moduloOperationToExpr op = - - let left = Syntax.moduloOperationLeft op - right = Syntax.moduloOperationRight op - in (Serialization.spaceSep [ - multiplicativeExpressionToExpr left, - (Serialization.cst "%"), - (unaryExpressionToExpr right)]) - --- | Convert a multiplicative expression to an expression -multiplicativeExpressionToExpr :: Syntax.MultiplicativeExpression -> Ast.Expr -multiplicativeExpressionToExpr e = - case e of - Syntax.MultiplicativeExpressionUnary v0 -> unaryExpressionToExpr v0 - Syntax.MultiplicativeExpressionMultiply v0 -> multiplyOperationToExpr v0 - Syntax.MultiplicativeExpressionDivide v0 -> divideOperationToExpr v0 - Syntax.MultiplicativeExpressionModulo v0 -> moduloOperationToExpr v0 - --- | Convert a multiply operation to an expression -multiplyOperationToExpr :: Syntax.MultiplyOperation -> Ast.Expr -multiplyOperationToExpr op = - - let left = Syntax.multiplyOperationLeft op - right = Syntax.multiplyOperationRight op - in (Serialization.spaceSep [ - multiplicativeExpressionToExpr left, - (Serialization.cst "*"), - (unaryExpressionToExpr right)]) - --- | Convert a namespace declaration to an expression -namespaceDeclarationToExpr :: Syntax.NamespaceDeclaration -> Ast.Expr -namespaceDeclarationToExpr nd = - - let name = Syntax.namespaceDeclarationName nd - decls = Syntax.namespaceDeclarationDeclarations nd - in (Serialization.spaceSep [ - Serialization.cst (Strings.concat2 "namespace " name), - (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map declarationToExpr decls)))]) - --- | Convert a not-equal operation to an expression -notEqualOperationToExpr :: Syntax.NotEqualOperation -> Ast.Expr -notEqualOperationToExpr op = - - let left = Syntax.notEqualOperationLeft op - right = Syntax.notEqualOperationRight op - in (Serialization.spaceSep [ - equalityExpressionToExpr left, - (Serialization.cst "!="), - (relationalExpressionToExpr right)]) - --- | Convert an optional to an expression -optionalToExpr :: Syntax.Optional -> Ast.Expr -optionalToExpr opt = - - let valType = Syntax.optionalValueType opt - val = Syntax.optionalValue opt - in (Serialization.spaceSep [ - Serialization.cst "std::optional<", - (typeExpressionToExpr valType), - (Serialization.cst ">"), - (Optionals.match val (Serialization.cst "{}") (\v -> Serialization.curlyBracesList Nothing Serialization.inlineStyle [ - expressionToExpr v]))]) - --- | Convert overloaded lambdas to an expression -overloadedLambdasToExpr :: Syntax.OverloadedLambdas -> Ast.Expr -overloadedLambdasToExpr ol = - Serialization.spaceSep [ - Serialization.cst "overloaded", - (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map lambdaExpressionToExpr (Syntax.unOverloadedLambdas ol))))] - --- | Convert a parameter to an expression -parameterToExpr :: Syntax.Parameter -> Ast.Expr -parameterToExpr p = - - let typ = Syntax.parameterType p - name = Syntax.parameterName p - unnamed = Syntax.parameterUnnamed p - defaultVal = Syntax.parameterDefaultValue p - nameExpr = - Serialization.cst (Logic.ifElse unnamed (Strings.concat [ - "/*", - name, - "*/"]) name) - in (Serialization.spaceSep (Lists.concat [ - [ - typeExpressionToExpr typ, - nameExpr], - (Optionals.match defaultVal [] (\expr -> [ - Serialization.cst "=", - (expressionToExpr expr)]))])) - --- | Convert a pattern match to an expression -patternMatchToExpr :: Syntax.PatternMatch -> Ast.Expr -patternMatchToExpr pm = - - let visitor = Syntax.patternMatchVisitor pm - variant = Syntax.patternMatchVariant pm - in (Serialization.spaceSep [ - Serialization.cst "std::visit", - (Serialization.parenListAdaptive [ - visitorToExpr visitor, - (expressionToExpr variant)])]) - --- | Convert a pointer member access operation to an expression -pointerMemberAccessOperationToExpr :: Syntax.PointerMemberAccessOperation -> Ast.Expr -pointerMemberAccessOperationToExpr pmao = - - let ptr = Syntax.pointerMemberAccessOperationPointer pmao - member = Syntax.pointerMemberAccessOperationMember pmao - in (Serialization.noSep [ - postfixExpressionToExpr ptr, - (Serialization.cst "->"), - (Serialization.cst member)]) - --- | Convert a postfix expression to an expression -postfixExpressionToExpr :: Syntax.PostfixExpression -> Ast.Expr -postfixExpressionToExpr e = - case e of - Syntax.PostfixExpressionPrimary v0 -> primaryExpressionToExpr v0 - Syntax.PostfixExpressionSubscript v0 -> subscriptOperationToExpr v0 - Syntax.PostfixExpressionFunctionCall v0 -> functionCallOperationToExpr v0 - Syntax.PostfixExpressionTemplateFunctionCall v0 -> templateFunctionCallOperationToExpr v0 - Syntax.PostfixExpressionMemberAccess v0 -> memberAccessOperationToExpr v0 - Syntax.PostfixExpressionPointerMemberAccess v0 -> pointerMemberAccessOperationToExpr v0 - Syntax.PostfixExpressionPostIncrement v0 -> Serialization.noSep [ - postfixExpressionToExpr v0, - (Serialization.cst "++")] - Syntax.PostfixExpressionPostDecrement v0 -> Serialization.noSep [ - postfixExpressionToExpr v0, - (Serialization.cst "--")] - --- | Convert a pragma directive to an expression -pragmaDirectiveToExpr :: Syntax.PragmaDirective -> Ast.Expr -pragmaDirectiveToExpr pd = Serialization.cst (Strings.concat2 "#pragma " (Syntax.pragmaDirectiveContent pd)) - --- | Convert a preprocessor directive to an expression -preprocessorDirectiveToExpr :: Syntax.PreprocessorDirective -> Ast.Expr -preprocessorDirectiveToExpr d = - case d of - Syntax.PreprocessorDirectiveInclude v0 -> includeDirectiveToExpr v0 - Syntax.PreprocessorDirectivePragma v0 -> pragmaDirectiveToExpr v0 - Syntax.PreprocessorDirectiveDefine v0 -> defineDirectiveToExpr v0 - Syntax.PreprocessorDirectiveUndef v0 -> undefDirectiveToExpr v0 - Syntax.PreprocessorDirectiveIfdef v0 -> ifdefDirectiveToExpr v0 - Syntax.PreprocessorDirectiveIfndef v0 -> ifndefDirectiveToExpr v0 - Syntax.PreprocessorDirectiveIf v0 -> ifDirectiveToExpr v0 - Syntax.PreprocessorDirectiveElif v0 -> elifDirectiveToExpr v0 - Syntax.PreprocessorDirectiveElse v0 -> elseDirectiveToExpr v0 - Syntax.PreprocessorDirectiveEndif v0 -> endifDirectiveToExpr v0 - Syntax.PreprocessorDirectiveLine v0 -> lineDirectiveToExpr v0 - Syntax.PreprocessorDirectiveError v0 -> errorDirectiveToExpr v0 - Syntax.PreprocessorDirectiveWarning v0 -> warningDirectiveToExpr v0 - --- | Convert a primary expression to an expression -primaryExpressionToExpr :: Syntax.PrimaryExpression -> Ast.Expr -primaryExpressionToExpr e = - case e of - Syntax.PrimaryExpressionIdentifier v0 -> Serialization.cst v0 - Syntax.PrimaryExpressionLiteral v0 -> literalToExpr v0 - Syntax.PrimaryExpressionParenthesized v0 -> Serialization.parens (expressionToExpr v0) - Syntax.PrimaryExpressionLambda v0 -> lambdaExpressionToExpr v0 - --- | Convert a program to an expression -programToExpr :: Syntax.Program -> Ast.Expr -programToExpr prog = - - let preps = Syntax.programPreprocessorDirectives prog - includes = Syntax.programIncludes prog - decls = Syntax.programDeclarations prog - separate = \sep -> \defs -> Logic.ifElse (Lists.isEmpty defs) Nothing (Just (sep defs)) - in (Serialization.doubleNewlineSep (Optionals.givens [ - separate Serialization.newlineSep (Lists.map preprocessorDirectiveToExpr preps), - (separate Serialization.newlineSep (Lists.map includeDirectiveToExpr includes)), - (separate Serialization.doubleNewlineSep (Lists.map declarationToExpr decls))])) - --- | Convert a qualified identifier to an expression -qualifiedIdentifierToExpr :: Syntax.QualifiedIdentifier -> Ast.Expr -qualifiedIdentifierToExpr qi = - - let ns = Syntax.qualifiedIdentifierNamespace qi - name = Syntax.qualifiedIdentifierName qi - in (Serialization.cst (Strings.concat [ - ns, - "::", - name])) - --- | Convert a qualified type to an expression -qualifiedTypeToExpr :: Syntax.QualifiedType -> Ast.Expr -qualifiedTypeToExpr qt = - - let baseType = Syntax.qualifiedTypeBaseType qt - qualifier = Syntax.qualifiedTypeQualifier qt - in case qualifier of - Syntax.TypeQualifierConst -> Serialization.spaceSep [ - Serialization.cst "const", - (typeExpressionToExpr baseType)] - Syntax.TypeQualifierLvalueRef -> Serialization.noSep [ - typeExpressionToExpr baseType, - (Serialization.cst "&")] - Syntax.TypeQualifierRvalueRef -> Serialization.noSep [ - typeExpressionToExpr baseType, - (Serialization.cst "&&")] - Syntax.TypeQualifierPointer -> Serialization.noSep [ - typeExpressionToExpr baseType, - (Serialization.cst "*")] - --- | Convert a range-for statement to an expression -rangeForStatementToExpr :: Syntax.RangeForStatement -> Ast.Expr -rangeForStatementToExpr rfs = - - let typ = Syntax.rangeForStatementType rfs - var = Syntax.rangeForStatementVariable rfs - range = Syntax.rangeForStatementRange rfs - body = Syntax.rangeForStatementBody rfs - in (Serialization.newlineSep [ - Serialization.spaceSep [ - Serialization.cst "for", - (Serialization.parens (Serialization.spaceSep [ - typeExpressionToExpr typ, - (Serialization.cst var), - (Serialization.cst ":"), - (expressionToExpr range)]))], - (statementToExpr body)]) - --- | Convert a relational expression to an expression -relationalExpressionToExpr :: Syntax.RelationalExpression -> Ast.Expr -relationalExpressionToExpr e = - case e of - Syntax.RelationalExpressionShift v0 -> shiftExpressionToExpr v0 - Syntax.RelationalExpressionLess v0 -> lessOperationToExpr v0 - Syntax.RelationalExpressionGreater v0 -> greaterOperationToExpr v0 - Syntax.RelationalExpressionLessEqual v0 -> lessEqualOperationToExpr v0 - Syntax.RelationalExpressionGreaterEqual v0 -> greaterEqualOperationToExpr v0 - --- | Convert a right shift operation to an expression -rightShiftOperationToExpr :: Syntax.RightShiftOperation -> Ast.Expr -rightShiftOperationToExpr op = - - let left = Syntax.rightShiftOperationLeft op - right = Syntax.rightShiftOperationRight op - in (Serialization.spaceSep [ - shiftExpressionToExpr left, - (Serialization.cst ">>"), - (additiveExpressionToExpr right)]) - --- | Convert a selection statement to an expression -selectionStatementToExpr :: Syntax.SelectionStatement -> Ast.Expr -selectionStatementToExpr ss = - - let cond = Syntax.selectionStatementCondition ss - thenBranch = Syntax.selectionStatementThenBranch ss - elseBranch = Syntax.selectionStatementElseBranch ss - in (Serialization.newlineSep [ - Serialization.spaceSep [ - Serialization.cst "if", - (Serialization.parens (expressionToExpr cond))], - (statementToExpr thenBranch), - (Optionals.match elseBranch (Serialization.cst "") (\stmt -> Serialization.newlineSep [ - Serialization.cst "else", - (statementToExpr stmt)]))]) - --- | Convert a set to an expression -setToExpr :: Syntax.Set -> Ast.Expr -setToExpr s = - - let elemType = Syntax.setElementType s - elems = Syntax.setElements s - in (Serialization.spaceSep [ - Serialization.cst "std::set<", - (typeExpressionToExpr elemType), - (Serialization.cst ">"), - (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map expressionToExpr elems))]) - --- | Convert a shift expression to an expression -shiftExpressionToExpr :: Syntax.ShiftExpression -> Ast.Expr -shiftExpressionToExpr e = - case e of - Syntax.ShiftExpressionAdditive v0 -> additiveExpressionToExpr v0 - Syntax.ShiftExpressionLeftShift v0 -> leftShiftOperationToExpr v0 - Syntax.ShiftExpressionRightShift v0 -> rightShiftOperationToExpr v0 - --- | Convert a sizeof expression to an expression -sizeofExpressionToExpr :: Syntax.SizeofExpression -> Ast.Expr -sizeofExpressionToExpr se = - Serialization.spaceSep [ - Serialization.cst "sizeof", - (Serialization.parens (typeExpressionToExpr (Syntax.unSizeofExpression se)))] - --- | Convert a statement to an expression -statementToExpr :: Syntax.Statement -> Ast.Expr -statementToExpr s = - case s of - Syntax.StatementLabeled v0 -> labeledStatementToExpr v0 - Syntax.StatementCompound v0 -> compoundStatementToExpr v0 - Syntax.StatementSelection v0 -> selectionStatementToExpr v0 - Syntax.StatementSwitch v0 -> switchStatementToExpr v0 - Syntax.StatementIteration v0 -> iterationStatementToExpr v0 - Syntax.StatementJump v0 -> jumpStatementToExpr v0 - Syntax.StatementDeclaration v0 -> Serialization.withSemi (variableDeclarationToExpr False v0) - Syntax.StatementExpression v0 -> Serialization.withSemi (expressionToExpr v0) - --- | Convert a subscript operation to an expression -subscriptOperationToExpr :: Syntax.SubscriptOperation -> Ast.Expr -subscriptOperationToExpr so = - - let array = Syntax.subscriptOperationArray so - index = Syntax.subscriptOperationIndex so - in (Serialization.noSep [ - postfixExpressionToExpr array, - (Serialization.cst "["), - (expressionToExpr index), - (Serialization.cst "]")]) - --- | Convert a subtract operation to an expression -subtractOperationToExpr :: Syntax.SubtractOperation -> Ast.Expr -subtractOperationToExpr op = - - let left = Syntax.subtractOperationLeft op - right = Syntax.subtractOperationRight op - in (Serialization.spaceSep [ - additiveExpressionToExpr left, - (Serialization.cst "-"), - (multiplicativeExpressionToExpr right)]) - --- | Convert a switch statement to an expression -switchStatementToExpr :: Syntax.SwitchStatement -> Ast.Expr -switchStatementToExpr ss = - - let value = Syntax.switchStatementValue ss - match = Syntax.switchStatementCases ss - in (Serialization.spaceSep [ - Serialization.cst "switch", - (Serialization.parens (expressionToExpr value)), - (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map caseStatementToExpr match)))]) - --- | Convert a template argument to an expression -templateArgumentToExpr :: Syntax.TemplateArgument -> Ast.Expr -templateArgumentToExpr a = - case a of - Syntax.TemplateArgumentType v0 -> typeExpressionToExpr v0 - Syntax.TemplateArgumentValue v0 -> expressionToExpr v0 - --- | Convert a template declaration to an expression -templateDeclarationToExpr :: Syntax.TemplateDeclaration -> Ast.Expr -templateDeclarationToExpr td = - - let inline = Syntax.templateDeclarationInline td - params = Syntax.templateDeclarationParameters td - declaration = Syntax.templateDeclarationDeclaration td - sep = Logic.ifElse inline Serialization.spaceSep Serialization.newlineSep - in (sep [ - Serialization.noSep [ - Serialization.cst "template", - (Serialization.angleBracesList Serialization.inlineStyle (Lists.map (\p -> Serialization.cst p) params))], - (declarationToExpr declaration)]) - --- | Convert a template function call operation to an expression -templateFunctionCallOperationToExpr :: Syntax.TemplateFunctionCallOperation -> Ast.Expr -templateFunctionCallOperationToExpr tfco = - - let func = Syntax.templateFunctionCallOperationFunction tfco - templateArgs = Syntax.templateFunctionCallOperationTemplateArguments tfco - args = Syntax.templateFunctionCallOperationArguments tfco - in (Serialization.noSep [ - postfixExpressionToExpr func, - (Serialization.angleBracesList Serialization.inlineStyle (Lists.map templateArgumentToExpr templateArgs)), - (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) - --- | Convert a template type to an expression -templateTypeToExpr :: Syntax.TemplateType -> Ast.Expr -templateTypeToExpr tt = - - let name = Syntax.templateTypeName tt - args = Syntax.templateTypeArguments tt - in (Serialization.noSep [ - Serialization.cst name, - (Serialization.angleBracesList Serialization.inlineStyle (Lists.map templateArgumentToExpr args))]) - --- | Convert a ternary expression to an expression -ternaryExpressionToExpr :: Syntax.TernaryExpression -> Ast.Expr -ternaryExpressionToExpr te = - - let cond = Syntax.ternaryExpressionCondition te - trueExpr = Syntax.ternaryExpressionTrueExpr te - falseExpr = Syntax.ternaryExpressionFalseExpr te - in (Serialization.spaceSep [ - logicalOrExpressionToExpr cond, - (Serialization.cst "?"), - (expressionToExpr trueExpr), - (Serialization.cst ":"), - (conditionalExpressionToExpr falseExpr)]) - --- | Convert a string to a C++ comment. Empty single-line comments emit `//` (no trailing space). -toCppComments :: String -> Bool -> String -toCppComments s isMultiline = - Logic.ifElse isMultiline (Strings.concat [ - "/* ", - s, - " */"]) (Logic.ifElse (Equality.equal s "") "//" (Strings.concat2 "// " s)) - --- | Convert a type expression to an expression -typeExpressionToExpr :: Syntax.TypeExpression -> Ast.Expr -typeExpressionToExpr t = - case t of - Syntax.TypeExpressionBasic v0 -> basicTypeToExpr v0 - Syntax.TypeExpressionQualified v0 -> qualifiedTypeToExpr v0 - Syntax.TypeExpressionTemplate v0 -> templateTypeToExpr v0 - Syntax.TypeExpressionFunction v0 -> functionTypeToExpr v0 - Syntax.TypeExpressionAuto -> Serialization.cst "auto" - --- | Convert a typedef declaration to an expression -typedefDeclarationToExpr :: Syntax.TypedefDeclaration -> Ast.Expr -typedefDeclarationToExpr td = - - let name = Syntax.typedefDeclarationName td - typ = Syntax.typedefDeclarationType td - isUsing = Syntax.typedefDeclarationIsUsing td - in (Logic.ifElse isUsing (Serialization.withSemi (Serialization.spaceSep [ - Serialization.cst (Strings.concat2 "using " name), - (Serialization.cst "="), - (typeExpressionToExpr typ)])) (Serialization.withSemi (Serialization.spaceSep [ - Serialization.cst "typedef", - (typeExpressionToExpr typ), - (Serialization.cst name)]))) - --- | Convert a unary expression to an expression -unaryExpressionToExpr :: Syntax.UnaryExpression -> Ast.Expr -unaryExpressionToExpr e = - case e of - Syntax.UnaryExpressionPostfix v0 -> postfixExpressionToExpr v0 - Syntax.UnaryExpressionUnaryOp v0 -> unaryOperationToExpr v0 - Syntax.UnaryExpressionSizeof v0 -> sizeofExpressionToExpr v0 - --- | Convert a unary operation to an expression -unaryOperationToExpr :: Syntax.UnaryOperation -> Ast.Expr -unaryOperationToExpr uo = - - let op = Syntax.unaryOperationOperator uo - operand = Syntax.unaryOperationOperand uo - in (Serialization.spaceSep [ - unaryOperatorToExpr op, - (unaryExpressionToExpr operand)]) - --- | Convert a unary operator to an expression -unaryOperatorToExpr :: Syntax.UnaryOperator -> Ast.Expr -unaryOperatorToExpr op = - case op of - Syntax.UnaryOperatorPlus -> Serialization.cst "+" - Syntax.UnaryOperatorMinus -> Serialization.cst "-" - Syntax.UnaryOperatorLogicalNot -> Serialization.cst "!" - Syntax.UnaryOperatorBitwiseNot -> Serialization.cst "~" - Syntax.UnaryOperatorDereference -> Serialization.cst "*" - Syntax.UnaryOperatorAddressOf -> Serialization.cst "&" - Syntax.UnaryOperatorPreIncrement -> Serialization.cst "++" - Syntax.UnaryOperatorPreDecrement -> Serialization.cst "--" - --- | Convert an undef directive to an expression -undefDirectiveToExpr :: Syntax.UndefDirective -> Ast.Expr -undefDirectiveToExpr ud = - Serialization.spaceSep [ - Serialization.cst "#undef", - (Serialization.cst (Syntax.undefDirectiveName ud))] - --- | Convert a variable declaration to an expression -variableDeclarationToExpr :: Bool -> Syntax.VariableDeclaration -> Ast.Expr -variableDeclarationToExpr commas vd = - - let typ = Syntax.variableDeclarationType vd - name = Syntax.variableDeclarationName vd - init = Syntax.variableDeclarationInitializer vd - isAuto = Syntax.variableDeclarationIsAuto vd - terminator = Logic.ifElse commas Serialization.withComma Serialization.withSemi - in (terminator (Serialization.spaceSep (Lists.concat [ - Logic.ifElse isAuto [ - Serialization.cst "auto"] (Optionals.match typ [] (\t -> [ - typeExpressionToExpr t])), - [ - Serialization.cst name], - (Optionals.match init [] (\expr -> [ - Serialization.cst "=", - (expressionToExpr expr)]))]))) - --- | Convert a vector to an expression -vectorToExpr :: Syntax.Vector -> Ast.Expr -vectorToExpr v = - - let elemType = Syntax.vectorElementType v - elems = Syntax.vectorElements v - in (Serialization.spaceSep [ - Serialization.cst "std::vector<", - (typeExpressionToExpr elemType), - (Serialization.cst ">"), - (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map expressionToExpr elems))]) - --- | Convert a visitor to an expression -visitorToExpr :: Syntax.Visitor -> Ast.Expr -visitorToExpr v = - case v of - Syntax.VisitorLambda v0 -> lambdaExpressionToExpr v0 - Syntax.VisitorOverloaded v0 -> overloadedLambdasToExpr v0 - --- | Convert a warning directive to an expression -warningDirectiveToExpr :: Syntax.WarningDirective -> Ast.Expr -warningDirectiveToExpr wd = - Serialization.spaceSep [ - Serialization.cst "#warning", - (Serialization.cst (Syntax.warningDirectiveMessage wd))] - --- | Convert a while statement to an expression -whileStatementToExpr :: Syntax.WhileStatement -> Ast.Expr -whileStatementToExpr ws = - - let cond = Syntax.whileStatementCondition ws - body = Syntax.whileStatementBody ws - in (Serialization.newlineSep [ - Serialization.spaceSep [ - Serialization.cst "while", - (Serialization.parens (expressionToExpr cond))], - (statementToExpr body)]) diff --git a/src/main/haskell/Hydra/Cpp/Syntax.hs b/src/main/haskell/Hydra/Cpp/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Syntax.hs +++ /dev/null @@ -1,2033 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A C++ syntax model, focusing on features for representing algebraic data types and declarative computations - -module Hydra.Cpp.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A C++ member or base-class access specifier: public, protected, or private -data AccessSpecifier = - AccessSpecifierPublic | - AccessSpecifierProtected | - AccessSpecifierPrivate | - AccessSpecifierNone - deriving (Eq, Ord, Read, Show) - -_AccessSpecifier = Core.Name "hydra.cpp.syntax.AccessSpecifier" - -_AccessSpecifier_public = Core.Name "public" - -_AccessSpecifier_protected = Core.Name "protected" - -_AccessSpecifier_private = Core.Name "private" - -_AccessSpecifier_none = Core.Name "none" - --- | A C++ binary addition expression (left + right) -data AddOperation = - AddOperation { - addOperationLeft :: AdditiveExpression, - addOperationRight :: MultiplicativeExpression} - deriving (Eq, Ord, Read, Show) - -_AddOperation = Core.Name "hydra.cpp.syntax.AddOperation" - -_AddOperation_left = Core.Name "left" - -_AddOperation_right = Core.Name "right" - --- | A C++ additive-expression: a multiplicative expression, an addition, or a subtraction -data AdditiveExpression = - AdditiveExpressionMultiplicative MultiplicativeExpression | - AdditiveExpressionAdd AddOperation | - AdditiveExpressionSubtract SubtractOperation - deriving (Eq, Ord, Read, Show) - -_AdditiveExpression = Core.Name "hydra.cpp.syntax.AdditiveExpression" - -_AdditiveExpression_multiplicative = Core.Name "multiplicative" - -_AdditiveExpression_add = Core.Name "add" - -_AdditiveExpression_subtract = Core.Name "subtract" - --- | A C++ and-expression: an equality expression or a bitwise AND operation -data AndExpression = - AndExpressionEquality EqualityExpression | - AndExpressionBitwiseAnd BitwiseAndOperation - deriving (Eq, Ord, Read, Show) - -_AndExpression = Core.Name "hydra.cpp.syntax.AndExpression" - -_AndExpression_equality = Core.Name "equality" - -_AndExpression_bitwiseAnd = Core.Name "bitwiseAnd" - --- | A C++ assignment-expression: a conditional expression or an explicit assignment -data AssignmentExpression = - AssignmentExpressionConditional ConditionalExpression | - AssignmentExpressionAssignment ExplicitAssignment - deriving (Eq, Ord, Read, Show) - -_AssignmentExpression = Core.Name "hydra.cpp.syntax.AssignmentExpression" - -_AssignmentExpression_conditional = Core.Name "conditional" - -_AssignmentExpression_assignment = Core.Name "assignment" - --- | A C++ assignment operator, such as =, +=, or <<= -data AssignmentOperator = - AssignmentOperatorAssign | - AssignmentOperatorPlusAssign | - AssignmentOperatorMinusAssign | - AssignmentOperatorMultiplyAssign | - AssignmentOperatorDivideAssign | - AssignmentOperatorModuloAssign | - AssignmentOperatorLeftShiftAssign | - AssignmentOperatorRightShiftAssign | - AssignmentOperatorBitwiseAndAssign | - AssignmentOperatorBitwiseXorAssign | - AssignmentOperatorBitwiseOrAssign - deriving (Eq, Ord, Read, Show) - -_AssignmentOperator = Core.Name "hydra.cpp.syntax.AssignmentOperator" - -_AssignmentOperator_assign = Core.Name "assign" - -_AssignmentOperator_plusAssign = Core.Name "plusAssign" - -_AssignmentOperator_minusAssign = Core.Name "minusAssign" - -_AssignmentOperator_multiplyAssign = Core.Name "multiplyAssign" - -_AssignmentOperator_divideAssign = Core.Name "divideAssign" - -_AssignmentOperator_moduloAssign = Core.Name "moduloAssign" - -_AssignmentOperator_leftShiftAssign = Core.Name "leftShiftAssign" - -_AssignmentOperator_rightShiftAssign = Core.Name "rightShiftAssign" - -_AssignmentOperator_bitwiseAndAssign = Core.Name "bitwiseAndAssign" - -_AssignmentOperator_bitwiseXorAssign = Core.Name "bitwiseXorAssign" - -_AssignmentOperator_bitwiseOrAssign = Core.Name "bitwiseOrAssign" - --- | A C++ base class specifier within a class's inheritance list -data BaseSpecifier = - BaseSpecifier { - baseSpecifierAccess :: AccessSpecifier, - baseSpecifierName :: String} - deriving (Eq, Ord, Read, Show) - -_BaseSpecifier = Core.Name "hydra.cpp.syntax.BaseSpecifier" - -_BaseSpecifier_access = Core.Name "access" - -_BaseSpecifier_name = Core.Name "name" - --- | A C++ built-in or named basic type -data BasicType = - BasicTypeVoid | - BasicTypeBool | - BasicTypeChar | - BasicTypeInt | - BasicTypeFloat | - BasicTypeDouble | - BasicTypeString | - BasicTypeAuto | - BasicTypeNamed String - deriving (Eq, Ord, Read, Show) - -_BasicType = Core.Name "hydra.cpp.syntax.BasicType" - -_BasicType_void = Core.Name "void" - -_BasicType_bool = Core.Name "bool" - -_BasicType_char = Core.Name "char" - -_BasicType_int = Core.Name "int" - -_BasicType_float = Core.Name "float" - -_BasicType_double = Core.Name "double" - -_BasicType_string = Core.Name "string" - -_BasicType_auto = Core.Name "auto" - -_BasicType_named = Core.Name "named" - --- | A C++ binary operator -data BinaryOperator = - BinaryOperatorPlus | - BinaryOperatorMinus | - BinaryOperatorMultiply | - BinaryOperatorDivide | - BinaryOperatorModulo | - BinaryOperatorBitwiseAnd | - BinaryOperatorBitwiseOr | - BinaryOperatorBitwiseXor | - BinaryOperatorLogicalAnd | - BinaryOperatorLogicalOr | - BinaryOperatorEqual | - BinaryOperatorNotEqual | - BinaryOperatorLess | - BinaryOperatorGreater | - BinaryOperatorLessEqual | - BinaryOperatorGreaterEqual | - BinaryOperatorLeftShift | - BinaryOperatorRightShift - deriving (Eq, Ord, Read, Show) - -_BinaryOperator = Core.Name "hydra.cpp.syntax.BinaryOperator" - -_BinaryOperator_plus = Core.Name "plus" - -_BinaryOperator_minus = Core.Name "minus" - -_BinaryOperator_multiply = Core.Name "multiply" - -_BinaryOperator_divide = Core.Name "divide" - -_BinaryOperator_modulo = Core.Name "modulo" - -_BinaryOperator_bitwiseAnd = Core.Name "bitwiseAnd" - -_BinaryOperator_bitwiseOr = Core.Name "bitwiseOr" - -_BinaryOperator_bitwiseXor = Core.Name "bitwiseXor" - -_BinaryOperator_logicalAnd = Core.Name "logicalAnd" - -_BinaryOperator_logicalOr = Core.Name "logicalOr" - -_BinaryOperator_equal = Core.Name "equal" - -_BinaryOperator_notEqual = Core.Name "notEqual" - -_BinaryOperator_less = Core.Name "less" - -_BinaryOperator_greater = Core.Name "greater" - -_BinaryOperator_lessEqual = Core.Name "lessEqual" - -_BinaryOperator_greaterEqual = Core.Name "greaterEqual" - -_BinaryOperator_leftShift = Core.Name "leftShift" - -_BinaryOperator_rightShift = Core.Name "rightShift" - --- | A C++ bitwise AND expression (left & right) -data BitwiseAndOperation = - BitwiseAndOperation { - bitwiseAndOperationLeft :: AndExpression, - bitwiseAndOperationRight :: EqualityExpression} - deriving (Eq, Ord, Read, Show) - -_BitwiseAndOperation = Core.Name "hydra.cpp.syntax.BitwiseAndOperation" - -_BitwiseAndOperation_left = Core.Name "left" - -_BitwiseAndOperation_right = Core.Name "right" - --- | A C++ bitwise OR expression (left | right) -data BitwiseOrOperation = - BitwiseOrOperation { - bitwiseOrOperationLeft :: InclusiveOrExpression, - bitwiseOrOperationRight :: ExclusiveOrExpression} - deriving (Eq, Ord, Read, Show) - -_BitwiseOrOperation = Core.Name "hydra.cpp.syntax.BitwiseOrOperation" - -_BitwiseOrOperation_left = Core.Name "left" - -_BitwiseOrOperation_right = Core.Name "right" - --- | A C++ bitwise XOR expression (left ^ right) -data BitwiseXorOperation = - BitwiseXorOperation { - bitwiseXorOperationLeft :: ExclusiveOrExpression, - bitwiseXorOperationRight :: AndExpression} - deriving (Eq, Ord, Read, Show) - -_BitwiseXorOperation = Core.Name "hydra.cpp.syntax.BitwiseXorOperation" - -_BitwiseXorOperation_left = Core.Name "left" - -_BitwiseXorOperation_right = Core.Name "right" - --- | A C++ boolean literal (true or false) -newtype BooleanLiteral = - BooleanLiteral { - unBooleanLiteral :: Bool} - deriving (Eq, Ord, Read, Show) - -_BooleanLiteral = Core.Name "hydra.cpp.syntax.BooleanLiteral" - --- | A single variable captured by a C++ lambda expression -data Capture = - Capture { - captureName :: String, - captureByReference :: Bool} - deriving (Eq, Ord, Read, Show) - -_Capture = Core.Name "hydra.cpp.syntax.Capture" - -_Capture_name = Core.Name "name" - -_Capture_byReference = Core.Name "byReference" - --- | A C++ lambda capture list: capture-by-value ([=]) or an explicit list of captures -data CaptureList = - CaptureListCaptureByValue | - CaptureListCaptures [Capture] - deriving (Eq, Ord, Read, Show) - -_CaptureList = Core.Name "hydra.cpp.syntax.CaptureList" - -_CaptureList_captureByValue = Core.Name "captureByValue" - -_CaptureList_captures = Core.Name "captures" - --- | A single case or default branch of a C++ switch statement -data CaseStatement = - CaseStatementCase CaseValue | - CaseStatementDefault Statement - deriving (Eq, Ord, Read, Show) - -_CaseStatement = Core.Name "hydra.cpp.syntax.CaseStatement" - -_CaseStatement_case = Core.Name "case" - -_CaseStatement_default = Core.Name "default" - --- | A C++ switch case label together with its associated statement -data CaseValue = - CaseValue { - caseValueValue :: Expression, - caseValueStatement :: Statement} - deriving (Eq, Ord, Read, Show) - -_CaseValue = Core.Name "hydra.cpp.syntax.CaseValue" - -_CaseValue_value = Core.Name "value" - -_CaseValue_statement = Core.Name "statement" - --- | A C++ character literal -newtype CharacterLiteral = - CharacterLiteral { - unCharacterLiteral :: String} - deriving (Eq, Ord, Read, Show) - -_CharacterLiteral = Core.Name "hydra.cpp.syntax.CharacterLiteral" - --- | The body of a C++ class, struct, or enum declaration: a list of member specifications -newtype ClassBody = - ClassBody { - unClassBody :: [MemberSpecification]} - deriving (Eq, Ord, Read, Show) - -_ClassBody = Core.Name "hydra.cpp.syntax.ClassBody" - --- | A C++ class, struct, or enum declaration, with an optional body -data ClassDeclaration = - ClassDeclaration { - classDeclarationSpecifier :: ClassSpecifier, - classDeclarationBody :: (Maybe ClassBody)} - deriving (Eq, Ord, Read, Show) - -_ClassDeclaration = Core.Name "hydra.cpp.syntax.ClassDeclaration" - -_ClassDeclaration_specifier = Core.Name "specifier" - -_ClassDeclaration_body = Core.Name "body" - --- | The keyword introducing a C++ class-like declaration: class, enum, enum class, or struct -data ClassKey = - ClassKeyClass | - ClassKeyEnum | - ClassKeyEnumClass | - ClassKeyStruct - deriving (Eq, Ord, Read, Show) - -_ClassKey = Core.Name "hydra.cpp.syntax.ClassKey" - -_ClassKey_class = Core.Name "class" - -_ClassKey_enum = Core.Name "enum" - -_ClassKey_enumClass = Core.Name "enumClass" - -_ClassKey_struct = Core.Name "struct" - --- | The head of a C++ class declaration: its key, name, and base class list -data ClassSpecifier = - ClassSpecifier { - classSpecifierKey :: ClassKey, - classSpecifierName :: String, - classSpecifierInheritance :: [BaseSpecifier]} - deriving (Eq, Ord, Read, Show) - -_ClassSpecifier = Core.Name "hydra.cpp.syntax.ClassSpecifier" - -_ClassSpecifier_key = Core.Name "key" - -_ClassSpecifier_name = Core.Name "name" - -_ClassSpecifier_inheritance = Core.Name "inheritance" - --- | A C++ comma expression (left, right) -data CommaExpression = - CommaExpression { - commaExpressionLeft :: Expression, - commaExpressionRight :: AssignmentExpression} - deriving (Eq, Ord, Read, Show) - -_CommaExpression = Core.Name "hydra.cpp.syntax.CommaExpression" - -_CommaExpression_left = Core.Name "left" - -_CommaExpression_right = Core.Name "right" - --- | A C++ line or block comment -data Comment = - Comment { - commentText :: String, - commentIsMultiline :: Bool} - deriving (Eq, Ord, Read, Show) - -_Comment = Core.Name "hydra.cpp.syntax.Comment" - -_Comment_text = Core.Name "text" - -_Comment_isMultiline = Core.Name "isMultiline" - --- | A C++ compound statement: a brace-enclosed block of statements -newtype CompoundStatement = - CompoundStatement { - unCompoundStatement :: [Statement]} - deriving (Eq, Ord, Read, Show) - -_CompoundStatement = Core.Name "hydra.cpp.syntax.CompoundStatement" - --- | A C++ conditional-expression: a logical-or expression or a ternary expression -data ConditionalExpression = - ConditionalExpressionLogicalOr LogicalOrExpression | - ConditionalExpressionTernary TernaryExpression - deriving (Eq, Ord, Read, Show) - -_ConditionalExpression = Core.Name "hydra.cpp.syntax.ConditionalExpression" - -_ConditionalExpression_logicalOr = Core.Name "logicalOr" - -_ConditionalExpression_ternary = Core.Name "ternary" - --- | A C++ constructor declaration, with parameters, member initializers, and a body -data ConstructorDeclaration = - ConstructorDeclaration { - constructorDeclarationName :: String, - constructorDeclarationParameters :: [Parameter], - constructorDeclarationInitializers :: [MemInitializer], - constructorDeclarationBody :: FunctionBody} - deriving (Eq, Ord, Read, Show) - -_ConstructorDeclaration = Core.Name "hydra.cpp.syntax.ConstructorDeclaration" - -_ConstructorDeclaration_name = Core.Name "name" - -_ConstructorDeclaration_parameters = Core.Name "parameters" - -_ConstructorDeclaration_initializers = Core.Name "initializers" - -_ConstructorDeclaration_body = Core.Name "body" - --- | A declaration of a standard-library container type alias: list, map, set, or optional -data ContainerDeclaration = - ContainerDeclarationList ListDeclaration | - ContainerDeclarationMap MapDeclaration | - ContainerDeclarationSet SetDeclaration | - ContainerDeclarationOptional OptionalDeclaration - deriving (Eq, Ord, Read, Show) - -_ContainerDeclaration = Core.Name "hydra.cpp.syntax.ContainerDeclaration" - -_ContainerDeclaration_list = Core.Name "list" - -_ContainerDeclaration_map = Core.Name "map" - -_ContainerDeclaration_set = Core.Name "set" - -_ContainerDeclaration_optional = Core.Name "optional" - --- | A top-level C++ declaration -data Declaration = - DeclarationPreprocessor PreprocessorDirective | - DeclarationClass ClassDeclaration | - DeclarationFunction FunctionDeclaration | - DeclarationVariable VariableDeclaration | - DeclarationTypedef TypedefDeclaration | - DeclarationNamespace NamespaceDeclaration | - DeclarationTemplate TemplateDeclaration - deriving (Eq, Ord, Read, Show) - -_Declaration = Core.Name "hydra.cpp.syntax.Declaration" - -_Declaration_preprocessor = Core.Name "preprocessor" - -_Declaration_class = Core.Name "class" - -_Declaration_function = Core.Name "function" - -_Declaration_variable = Core.Name "variable" - -_Declaration_typedef = Core.Name "typedef" - -_Declaration_namespace = Core.Name "namespace" - -_Declaration_template = Core.Name "template" - --- | A C preprocessor #define directive, optionally function-like -data DefineDirective = - DefineDirective { - defineDirectiveName :: String, - defineDirectiveParameters :: (Maybe [String]), - defineDirectiveReplacement :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_DefineDirective = Core.Name "hydra.cpp.syntax.DefineDirective" - -_DefineDirective_name = Core.Name "name" - -_DefineDirective_parameters = Core.Name "parameters" - -_DefineDirective_replacement = Core.Name "replacement" - --- | A C++ destructor declaration -data DestructorDeclaration = - DestructorDeclaration { - destructorDeclarationPrefixSpecifiers :: [FunctionSpecifierPrefix], - destructorDeclarationName :: String, - destructorDeclarationSuffixSpecifiers :: [FunctionSpecifierSuffix], - destructorDeclarationBody :: FunctionBody} - deriving (Eq, Ord, Read, Show) - -_DestructorDeclaration = Core.Name "hydra.cpp.syntax.DestructorDeclaration" - -_DestructorDeclaration_prefixSpecifiers = Core.Name "prefixSpecifiers" - -_DestructorDeclaration_name = Core.Name "name" - -_DestructorDeclaration_suffixSpecifiers = Core.Name "suffixSpecifiers" - -_DestructorDeclaration_body = Core.Name "body" - --- | A C++ division expression (left / right) -data DivideOperation = - DivideOperation { - divideOperationLeft :: MultiplicativeExpression, - divideOperationRight :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_DivideOperation = Core.Name "hydra.cpp.syntax.DivideOperation" - -_DivideOperation_left = Core.Name "left" - -_DivideOperation_right = Core.Name "right" - --- | A C++ do-while statement -data DoStatement = - DoStatement { - doStatementBody :: Statement, - doStatementCondition :: Expression} - deriving (Eq, Ord, Read, Show) - -_DoStatement = Core.Name "hydra.cpp.syntax.DoStatement" - -_DoStatement_body = Core.Name "body" - -_DoStatement_condition = Core.Name "condition" - --- | A C preprocessor #elif directive -data ElifDirective = - ElifDirective { - elifDirectiveCondition :: String} - deriving (Eq, Ord, Read, Show) - -_ElifDirective = Core.Name "hydra.cpp.syntax.ElifDirective" - -_ElifDirective_condition = Core.Name "condition" - --- | A C preprocessor #else directive -type ElseDirective = () - -_ElseDirective = Core.Name "hydra.cpp.syntax.ElseDirective" - --- | A C preprocessor #endif directive -type EndifDirective = () - -_EndifDirective = Core.Name "hydra.cpp.syntax.EndifDirective" - --- | A C++ equality comparison expression (left == right) -data EqualOperation = - EqualOperation { - equalOperationLeft :: EqualityExpression, - equalOperationRight :: RelationalExpression} - deriving (Eq, Ord, Read, Show) - -_EqualOperation = Core.Name "hydra.cpp.syntax.EqualOperation" - -_EqualOperation_left = Core.Name "left" - -_EqualOperation_right = Core.Name "right" - --- | A C++ equality-expression: a relational expression, an equality, or an inequality -data EqualityExpression = - EqualityExpressionRelational RelationalExpression | - EqualityExpressionEqual EqualOperation | - EqualityExpressionNotEqual NotEqualOperation - deriving (Eq, Ord, Read, Show) - -_EqualityExpression = Core.Name "hydra.cpp.syntax.EqualityExpression" - -_EqualityExpression_relational = Core.Name "relational" - -_EqualityExpression_equal = Core.Name "equal" - -_EqualityExpression_notEqual = Core.Name "notEqual" - --- | A C preprocessor #error directive -data ErrorDirective = - ErrorDirective { - errorDirectiveMessage :: String} - deriving (Eq, Ord, Read, Show) - -_ErrorDirective = Core.Name "hydra.cpp.syntax.ErrorDirective" - -_ErrorDirective_message = Core.Name "message" - --- | A C++ exclusive-or-expression: an and expression or a bitwise XOR operation -data ExclusiveOrExpression = - ExclusiveOrExpressionAnd AndExpression | - ExclusiveOrExpressionBitwiseXor BitwiseXorOperation - deriving (Eq, Ord, Read, Show) - -_ExclusiveOrExpression = Core.Name "hydra.cpp.syntax.ExclusiveOrExpression" - -_ExclusiveOrExpression_and = Core.Name "and" - -_ExclusiveOrExpression_bitwiseXor = Core.Name "bitwiseXor" - --- | A C++ assignment expression with an explicit operator (e.g. left += right) -data ExplicitAssignment = - ExplicitAssignment { - explicitAssignmentLeft :: LogicalOrExpression, - explicitAssignmentOp :: AssignmentOperator, - explicitAssignmentRight :: AssignmentExpression} - deriving (Eq, Ord, Read, Show) - -_ExplicitAssignment = Core.Name "hydra.cpp.syntax.ExplicitAssignment" - -_ExplicitAssignment_left = Core.Name "left" - -_ExplicitAssignment_op = Core.Name "op" - -_ExplicitAssignment_right = Core.Name "right" - --- | A C++ expression: an assignment expression or a comma expression -data Expression = - ExpressionAssignment AssignmentExpression | - ExpressionComma CommaExpression - deriving (Eq, Ord, Read, Show) - -_Expression = Core.Name "hydra.cpp.syntax.Expression" - -_Expression_assignment = Core.Name "assignment" - -_Expression_comma = Core.Name "comma" - --- | A C++ expression statement: an expression followed by a semicolon -newtype ExpressionStatement = - ExpressionStatement { - unExpressionStatement :: Expression} - deriving (Eq, Ord, Read, Show) - -_ExpressionStatement = Core.Name "hydra.cpp.syntax.ExpressionStatement" - --- | A C++ floating-point literal -newtype FloatingLiteral = - FloatingLiteral { - unFloatingLiteral :: Double} - deriving (Eq, Ord, Read, Show) - -_FloatingLiteral = Core.Name "hydra.cpp.syntax.FloatingLiteral" - --- | The initializer clause of a C++ for statement: an expression, a declaration, or empty -data ForInit = - ForInitExpression Expression | - ForInitDeclaration VariableDeclaration | - ForInitEmpty - deriving (Eq, Ord, Read, Show) - -_ForInit = Core.Name "hydra.cpp.syntax.ForInit" - -_ForInit_expression = Core.Name "expression" - -_ForInit_declaration = Core.Name "declaration" - -_ForInit_empty = Core.Name "empty" - --- | A C++ for statement -data ForStatement = - ForStatement { - forStatementInit :: ForInit, - forStatementCondition :: Expression, - forStatementIncrement :: Expression, - forStatementBody :: Statement} - deriving (Eq, Ord, Read, Show) - -_ForStatement = Core.Name "hydra.cpp.syntax.ForStatement" - -_ForStatement_init = Core.Name "init" - -_ForStatement_condition = Core.Name "condition" - -_ForStatement_increment = Core.Name "increment" - -_ForStatement_body = Core.Name "body" - --- | A simplified function call: a function identifier applied to a list of arguments -data FunctionApplication = - FunctionApplication { - functionApplicationFunction :: FunctionIdentifier, - functionApplicationArguments :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_FunctionApplication = Core.Name "hydra.cpp.syntax.FunctionApplication" - -_FunctionApplication_function = Core.Name "function" - -_FunctionApplication_arguments = Core.Name "arguments" - --- | The body of a C++ function: a compound statement, or a declaration-only/pure/default marker -data FunctionBody = - FunctionBodyCompound CompoundStatement | - FunctionBodyDeclaration | - FunctionBodyPure | - FunctionBodyDefault - deriving (Eq, Ord, Read, Show) - -_FunctionBody = Core.Name "hydra.cpp.syntax.FunctionBody" - -_FunctionBody_compound = Core.Name "compound" - -_FunctionBody_declaration = Core.Name "declaration" - -_FunctionBody_pure = Core.Name "pure" - -_FunctionBody_default = Core.Name "default" - --- | A C++ function call expression: a postfix expression applied to arguments -data FunctionCallOperation = - FunctionCallOperation { - functionCallOperationFunction :: PostfixExpression, - functionCallOperationArguments :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_FunctionCallOperation = Core.Name "hydra.cpp.syntax.FunctionCallOperation" - -_FunctionCallOperation_function = Core.Name "function" - -_FunctionCallOperation_arguments = Core.Name "arguments" - --- | A C++ function declaration or definition -data FunctionDeclaration = - FunctionDeclaration { - functionDeclarationPrefixSpecifiers :: [FunctionSpecifierPrefix], - functionDeclarationReturnType :: TypeExpression, - functionDeclarationName :: String, - functionDeclarationParameters :: [Parameter], - functionDeclarationSuffixSpecifiers :: [FunctionSpecifierSuffix], - functionDeclarationBody :: FunctionBody} - deriving (Eq, Ord, Read, Show) - -_FunctionDeclaration = Core.Name "hydra.cpp.syntax.FunctionDeclaration" - -_FunctionDeclaration_prefixSpecifiers = Core.Name "prefixSpecifiers" - -_FunctionDeclaration_returnType = Core.Name "returnType" - -_FunctionDeclaration_name = Core.Name "name" - -_FunctionDeclaration_parameters = Core.Name "parameters" - -_FunctionDeclaration_suffixSpecifiers = Core.Name "suffixSpecifiers" - -_FunctionDeclaration_body = Core.Name "body" - --- | The identifier of a called function: a simple name or a qualified name -data FunctionIdentifier = - FunctionIdentifierSimple String | - FunctionIdentifierQualified QualifiedIdentifier - deriving (Eq, Ord, Read, Show) - -_FunctionIdentifier = Core.Name "hydra.cpp.syntax.FunctionIdentifier" - -_FunctionIdentifier_simple = Core.Name "simple" - -_FunctionIdentifier_qualified = Core.Name "qualified" - --- | A C++ function specifier that appears before the declaration: inline, virtual, static, or explicit -data FunctionSpecifierPrefix = - FunctionSpecifierPrefixInline | - FunctionSpecifierPrefixVirtual | - FunctionSpecifierPrefixStatic | - FunctionSpecifierPrefixExplicit - deriving (Eq, Ord, Read, Show) - -_FunctionSpecifierPrefix = Core.Name "hydra.cpp.syntax.FunctionSpecifierPrefix" - -_FunctionSpecifierPrefix_inline = Core.Name "inline" - -_FunctionSpecifierPrefix_virtual = Core.Name "virtual" - -_FunctionSpecifierPrefix_static = Core.Name "static" - -_FunctionSpecifierPrefix_explicit = Core.Name "explicit" - --- | A C++ function specifier that appears after the parameter list: const, noexcept, override, or final -data FunctionSpecifierSuffix = - FunctionSpecifierSuffixConst | - FunctionSpecifierSuffixNoexcept | - FunctionSpecifierSuffixOverride | - FunctionSpecifierSuffixFinal - deriving (Eq, Ord, Read, Show) - -_FunctionSpecifierSuffix = Core.Name "hydra.cpp.syntax.FunctionSpecifierSuffix" - -_FunctionSpecifierSuffix_const = Core.Name "const" - -_FunctionSpecifierSuffix_noexcept = Core.Name "noexcept" - -_FunctionSpecifierSuffix_override = Core.Name "override" - -_FunctionSpecifierSuffix_final = Core.Name "final" - --- | A C++ function type: a return type together with parameter types -data FunctionType = - FunctionType { - functionTypeReturnType :: TypeExpression, - functionTypeParameters :: [Parameter]} - deriving (Eq, Ord, Read, Show) - -_FunctionType = Core.Name "hydra.cpp.syntax.FunctionType" - -_FunctionType_returnType = Core.Name "returnType" - -_FunctionType_parameters = Core.Name "parameters" - --- | A C++ greater-than-or-equal comparison expression (left >= right) -data GreaterEqualOperation = - GreaterEqualOperation { - greaterEqualOperationLeft :: RelationalExpression, - greaterEqualOperationRight :: ShiftExpression} - deriving (Eq, Ord, Read, Show) - -_GreaterEqualOperation = Core.Name "hydra.cpp.syntax.GreaterEqualOperation" - -_GreaterEqualOperation_left = Core.Name "left" - -_GreaterEqualOperation_right = Core.Name "right" - --- | A C++ greater-than comparison expression (left > right) -data GreaterOperation = - GreaterOperation { - greaterOperationLeft :: RelationalExpression, - greaterOperationRight :: ShiftExpression} - deriving (Eq, Ord, Read, Show) - -_GreaterOperation = Core.Name "hydra.cpp.syntax.GreaterOperation" - -_GreaterOperation_left = Core.Name "left" - -_GreaterOperation_right = Core.Name "right" - --- | A C++ identifier -type Identifier = String - -_Identifier = Core.Name "hydra.cpp.syntax.Identifier" - --- | A C preprocessor #if directive -data IfDirective = - IfDirective { - ifDirectiveCondition :: String} - deriving (Eq, Ord, Read, Show) - -_IfDirective = Core.Name "hydra.cpp.syntax.IfDirective" - -_IfDirective_condition = Core.Name "condition" - --- | A C preprocessor #ifdef directive -data IfdefDirective = - IfdefDirective { - ifdefDirectiveIdentifier :: String} - deriving (Eq, Ord, Read, Show) - -_IfdefDirective = Core.Name "hydra.cpp.syntax.IfdefDirective" - -_IfdefDirective_identifier = Core.Name "identifier" - --- | A C preprocessor #ifndef directive -data IfndefDirective = - IfndefDirective { - ifndefDirectiveIdentifier :: String} - deriving (Eq, Ord, Read, Show) - -_IfndefDirective = Core.Name "hydra.cpp.syntax.IfndefDirective" - -_IfndefDirective_identifier = Core.Name "identifier" - --- | A C preprocessor #include directive, for a system or local header -data IncludeDirective = - IncludeDirective { - includeDirectiveName :: String, - includeDirectiveIsSystem :: Bool} - deriving (Eq, Ord, Read, Show) - -_IncludeDirective = Core.Name "hydra.cpp.syntax.IncludeDirective" - -_IncludeDirective_name = Core.Name "name" - -_IncludeDirective_isSystem = Core.Name "isSystem" - --- | A C++ inclusive-or-expression: an exclusive-or expression or a bitwise OR operation -data InclusiveOrExpression = - InclusiveOrExpressionExclusiveOr ExclusiveOrExpression | - InclusiveOrExpressionBitwiseOr BitwiseOrOperation - deriving (Eq, Ord, Read, Show) - -_InclusiveOrExpression = Core.Name "hydra.cpp.syntax.InclusiveOrExpression" - -_InclusiveOrExpression_exclusiveOr = Core.Name "exclusiveOr" - -_InclusiveOrExpression_bitwiseOr = Core.Name "bitwiseOr" - --- | A C++ integer literal, in decimal, hexadecimal, octal, or binary form -data IntegerLiteral = - IntegerLiteralDecimal Integer | - IntegerLiteralHexadecimal String | - IntegerLiteralOctal String | - IntegerLiteralBinary String - deriving (Eq, Ord, Read, Show) - -_IntegerLiteral = Core.Name "hydra.cpp.syntax.IntegerLiteral" - -_IntegerLiteral_decimal = Core.Name "decimal" - -_IntegerLiteral_hexadecimal = Core.Name "hexadecimal" - -_IntegerLiteral_octal = Core.Name "octal" - -_IntegerLiteral_binary = Core.Name "binary" - --- | A C++ iteration statement: while, do-while, for, or range-based for -data IterationStatement = - IterationStatementWhile WhileStatement | - IterationStatementDo DoStatement | - IterationStatementFor ForStatement | - IterationStatementRangeFor RangeForStatement - deriving (Eq, Ord, Read, Show) - -_IterationStatement = Core.Name "hydra.cpp.syntax.IterationStatement" - -_IterationStatement_while = Core.Name "while" - -_IterationStatement_do = Core.Name "do" - -_IterationStatement_for = Core.Name "for" - -_IterationStatement_rangeFor = Core.Name "rangeFor" - --- | A C++ jump statement: break, continue, return (with or without a value), or throw -data JumpStatement = - JumpStatementBreak | - JumpStatementContinue | - JumpStatementReturnValue Expression | - JumpStatementReturnVoid | - JumpStatementThrow Expression - deriving (Eq, Ord, Read, Show) - -_JumpStatement = Core.Name "hydra.cpp.syntax.JumpStatement" - -_JumpStatement_break = Core.Name "break" - -_JumpStatement_continue = Core.Name "continue" - -_JumpStatement_returnValue = Core.Name "returnValue" - -_JumpStatement_returnVoid = Core.Name "returnVoid" - -_JumpStatement_throw = Core.Name "throw" - --- | A C++ labeled statement -data LabeledStatement = - LabeledStatement { - labeledStatementLabel :: String, - labeledStatementStatement :: Statement} - deriving (Eq, Ord, Read, Show) - -_LabeledStatement = Core.Name "hydra.cpp.syntax.LabeledStatement" - -_LabeledStatement_label = Core.Name "label" - -_LabeledStatement_statement = Core.Name "statement" - --- | A C++ lambda expression -data LambdaExpression = - LambdaExpression { - lambdaExpressionCaptures :: CaptureList, - lambdaExpressionParameters :: [Parameter], - lambdaExpressionReturnType :: (Maybe TypeExpression), - lambdaExpressionBody :: CompoundStatement} - deriving (Eq, Ord, Read, Show) - -_LambdaExpression = Core.Name "hydra.cpp.syntax.LambdaExpression" - -_LambdaExpression_captures = Core.Name "captures" - -_LambdaExpression_parameters = Core.Name "parameters" - -_LambdaExpression_returnType = Core.Name "returnType" - -_LambdaExpression_body = Core.Name "body" - --- | A C++ left shift expression (left << right) -data LeftShiftOperation = - LeftShiftOperation { - leftShiftOperationLeft :: ShiftExpression, - leftShiftOperationRight :: AdditiveExpression} - deriving (Eq, Ord, Read, Show) - -_LeftShiftOperation = Core.Name "hydra.cpp.syntax.LeftShiftOperation" - -_LeftShiftOperation_left = Core.Name "left" - -_LeftShiftOperation_right = Core.Name "right" - --- | A C++ less-than-or-equal comparison expression (left <= right) -data LessEqualOperation = - LessEqualOperation { - lessEqualOperationLeft :: RelationalExpression, - lessEqualOperationRight :: ShiftExpression} - deriving (Eq, Ord, Read, Show) - -_LessEqualOperation = Core.Name "hydra.cpp.syntax.LessEqualOperation" - -_LessEqualOperation_left = Core.Name "left" - -_LessEqualOperation_right = Core.Name "right" - --- | A C++ less-than comparison expression (left < right) -data LessOperation = - LessOperation { - lessOperationLeft :: RelationalExpression, - lessOperationRight :: ShiftExpression} - deriving (Eq, Ord, Read, Show) - -_LessOperation = Core.Name "hydra.cpp.syntax.LessOperation" - -_LessOperation_left = Core.Name "left" - -_LessOperation_right = Core.Name "right" - --- | A C preprocessor #line directive -data LineDirective = - LineDirective { - lineDirectiveLineNumber :: Int, - lineDirectiveFilename :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_LineDirective = Core.Name "hydra.cpp.syntax.LineDirective" - -_LineDirective_lineNumber = Core.Name "lineNumber" - -_LineDirective_filename = Core.Name "filename" - --- | A declaration of a named std::vector type alias -data ListDeclaration = - ListDeclaration { - listDeclarationElementType :: TypeExpression, - listDeclarationName :: String} - deriving (Eq, Ord, Read, Show) - -_ListDeclaration = Core.Name "hydra.cpp.syntax.ListDeclaration" - -_ListDeclaration_elementType = Core.Name "elementType" - -_ListDeclaration_name = Core.Name "name" - --- | A C++ literal value -data Literal = - LiteralInteger IntegerLiteral | - LiteralFloating FloatingLiteral | - LiteralCharacter CharacterLiteral | - LiteralString StringLiteral | - LiteralBoolean BooleanLiteral | - LiteralNull - deriving (Eq, Ord, Read, Show) - -_Literal = Core.Name "hydra.cpp.syntax.Literal" - -_Literal_integer = Core.Name "integer" - -_Literal_floating = Core.Name "floating" - -_Literal_character = Core.Name "character" - -_Literal_string = Core.Name "string" - -_Literal_boolean = Core.Name "boolean" - -_Literal_null = Core.Name "null" - --- | A C++ logical-and-expression: an inclusive-or expression or a logical AND operation -data LogicalAndExpression = - LogicalAndExpressionInclusiveOr InclusiveOrExpression | - LogicalAndExpressionLogicalAnd LogicalAndOperation - deriving (Eq, Ord, Read, Show) - -_LogicalAndExpression = Core.Name "hydra.cpp.syntax.LogicalAndExpression" - -_LogicalAndExpression_inclusiveOr = Core.Name "inclusiveOr" - -_LogicalAndExpression_logicalAnd = Core.Name "logicalAnd" - --- | A C++ logical AND expression (left && right) -data LogicalAndOperation = - LogicalAndOperation { - logicalAndOperationLeft :: LogicalAndExpression, - logicalAndOperationRight :: InclusiveOrExpression} - deriving (Eq, Ord, Read, Show) - -_LogicalAndOperation = Core.Name "hydra.cpp.syntax.LogicalAndOperation" - -_LogicalAndOperation_left = Core.Name "left" - -_LogicalAndOperation_right = Core.Name "right" - --- | A C++ logical-or-expression: a logical-and expression or a logical OR operation -data LogicalOrExpression = - LogicalOrExpressionLogicalAnd LogicalAndExpression | - LogicalOrExpressionLogicalOr LogicalOrOperation - deriving (Eq, Ord, Read, Show) - -_LogicalOrExpression = Core.Name "hydra.cpp.syntax.LogicalOrExpression" - -_LogicalOrExpression_logicalAnd = Core.Name "logicalAnd" - -_LogicalOrExpression_logicalOr = Core.Name "logicalOr" - --- | A C++ logical OR expression (left || right) -data LogicalOrOperation = - LogicalOrOperation { - logicalOrOperationLeft :: LogicalOrExpression, - logicalOrOperationRight :: LogicalAndExpression} - deriving (Eq, Ord, Read, Show) - -_LogicalOrOperation = Core.Name "hydra.cpp.syntax.LogicalOrOperation" - -_LogicalOrOperation_left = Core.Name "left" - -_LogicalOrOperation_right = Core.Name "right" - --- | A C++ std::map literal, with a key type, a value type, and entries -data Map = - Map { - mapKeyType :: TypeExpression, - mapValueType :: TypeExpression, - mapEntries :: [MapEntry]} - deriving (Eq, Ord, Read, Show) - -_Map = Core.Name "hydra.cpp.syntax.Map" - -_Map_keyType = Core.Name "keyType" - -_Map_valueType = Core.Name "valueType" - -_Map_entries = Core.Name "entries" - --- | A declaration of a named std::map type alias -data MapDeclaration = - MapDeclaration { - mapDeclarationKeyType :: TypeExpression, - mapDeclarationValueType :: TypeExpression, - mapDeclarationName :: String} - deriving (Eq, Ord, Read, Show) - -_MapDeclaration = Core.Name "hydra.cpp.syntax.MapDeclaration" - -_MapDeclaration_keyType = Core.Name "keyType" - -_MapDeclaration_valueType = Core.Name "valueType" - -_MapDeclaration_name = Core.Name "name" - --- | A single key/value entry in a C++ map literal -data MapEntry = - MapEntry { - mapEntryKey :: Expression, - mapEntryValue :: Expression} - deriving (Eq, Ord, Read, Show) - -_MapEntry = Core.Name "hydra.cpp.syntax.MapEntry" - -_MapEntry_key = Core.Name "key" - -_MapEntry_value = Core.Name "value" - --- | A C++ member initializer in a constructor's initializer list -data MemInitializer = - MemInitializer { - memInitializerName :: String, - memInitializerArguments :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_MemInitializer = Core.Name "hydra.cpp.syntax.MemInitializer" - -_MemInitializer_name = Core.Name "name" - -_MemInitializer_arguments = Core.Name "arguments" - --- | A C++ member access expression (object.member) -data MemberAccessOperation = - MemberAccessOperation { - memberAccessOperationObject :: PostfixExpression, - memberAccessOperationMember :: String} - deriving (Eq, Ord, Read, Show) - -_MemberAccessOperation = Core.Name "hydra.cpp.syntax.MemberAccessOperation" - -_MemberAccessOperation_object = Core.Name "object" - -_MemberAccessOperation_member = Core.Name "member" - --- | A single member declaration within a C++ class body -data MemberDeclaration = - MemberDeclarationFunction FunctionDeclaration | - MemberDeclarationVariable VariableDeclaration | - MemberDeclarationConstructor ConstructorDeclaration | - MemberDeclarationDestructor DestructorDeclaration | - MemberDeclarationNestedClass ClassDeclaration | - MemberDeclarationTemplate TemplateDeclaration - deriving (Eq, Ord, Read, Show) - -_MemberDeclaration = Core.Name "hydra.cpp.syntax.MemberDeclaration" - -_MemberDeclaration_function = Core.Name "function" - -_MemberDeclaration_variable = Core.Name "variable" - -_MemberDeclaration_constructor = Core.Name "constructor" - -_MemberDeclaration_destructor = Core.Name "destructor" - -_MemberDeclaration_nestedClass = Core.Name "nestedClass" - -_MemberDeclaration_template = Core.Name "template" - --- | An entry in a C++ class body: an access-level label or a member declaration -data MemberSpecification = - MemberSpecificationAccessLabel AccessSpecifier | - MemberSpecificationMember MemberDeclaration - deriving (Eq, Ord, Read, Show) - -_MemberSpecification = Core.Name "hydra.cpp.syntax.MemberSpecification" - -_MemberSpecification_accessLabel = Core.Name "accessLabel" - -_MemberSpecification_member = Core.Name "member" - --- | A C++ modulo expression (left % right) -data ModuloOperation = - ModuloOperation { - moduloOperationLeft :: MultiplicativeExpression, - moduloOperationRight :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_ModuloOperation = Core.Name "hydra.cpp.syntax.ModuloOperation" - -_ModuloOperation_left = Core.Name "left" - -_ModuloOperation_right = Core.Name "right" - --- | A C++ multiplicative-expression: a unary expression, a multiplication, a division, or a modulo -data MultiplicativeExpression = - MultiplicativeExpressionUnary UnaryExpression | - MultiplicativeExpressionMultiply MultiplyOperation | - MultiplicativeExpressionDivide DivideOperation | - MultiplicativeExpressionModulo ModuloOperation - deriving (Eq, Ord, Read, Show) - -_MultiplicativeExpression = Core.Name "hydra.cpp.syntax.MultiplicativeExpression" - -_MultiplicativeExpression_unary = Core.Name "unary" - -_MultiplicativeExpression_multiply = Core.Name "multiply" - -_MultiplicativeExpression_divide = Core.Name "divide" - -_MultiplicativeExpression_modulo = Core.Name "modulo" - --- | A C++ multiplication expression (left * right) -data MultiplyOperation = - MultiplyOperation { - multiplyOperationLeft :: MultiplicativeExpression, - multiplyOperationRight :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_MultiplyOperation = Core.Name "hydra.cpp.syntax.MultiplyOperation" - -_MultiplyOperation_left = Core.Name "left" - -_MultiplyOperation_right = Core.Name "right" - --- | A C++ namespace declaration enclosing a list of declarations -data NamespaceDeclaration = - NamespaceDeclaration { - namespaceDeclarationName :: String, - namespaceDeclarationDeclarations :: [Declaration]} - deriving (Eq, Ord, Read, Show) - -_NamespaceDeclaration = Core.Name "hydra.cpp.syntax.NamespaceDeclaration" - -_NamespaceDeclaration_name = Core.Name "name" - -_NamespaceDeclaration_declarations = Core.Name "declarations" - --- | A C++ inequality comparison expression (left != right) -data NotEqualOperation = - NotEqualOperation { - notEqualOperationLeft :: EqualityExpression, - notEqualOperationRight :: RelationalExpression} - deriving (Eq, Ord, Read, Show) - -_NotEqualOperation = Core.Name "hydra.cpp.syntax.NotEqualOperation" - -_NotEqualOperation_left = Core.Name "left" - -_NotEqualOperation_right = Core.Name "right" - --- | A C++ std::optional literal, with a value type and an optional contained value -data Optional = - Optional { - optionalValueType :: TypeExpression, - optionalValue :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_Optional = Core.Name "hydra.cpp.syntax.Optional" - -_Optional_valueType = Core.Name "valueType" - -_Optional_value = Core.Name "value" - --- | A declaration of a named std::optional type alias -data OptionalDeclaration = - OptionalDeclaration { - optionalDeclarationValueType :: TypeExpression, - optionalDeclarationName :: String} - deriving (Eq, Ord, Read, Show) - -_OptionalDeclaration = Core.Name "hydra.cpp.syntax.OptionalDeclaration" - -_OptionalDeclaration_valueType = Core.Name "valueType" - -_OptionalDeclaration_name = Core.Name "name" - --- | A set of lambda expressions combined via an overload pattern (e.g. a visitor helper) -newtype OverloadedLambdas = - OverloadedLambdas { - unOverloadedLambdas :: [LambdaExpression]} - deriving (Eq, Ord, Read, Show) - -_OverloadedLambdas = Core.Name "hydra.cpp.syntax.OverloadedLambdas" - --- | A C++ function or lambda parameter -data Parameter = - Parameter { - parameterType :: TypeExpression, - parameterName :: String, - parameterUnnamed :: Bool, - parameterDefaultValue :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_Parameter = Core.Name "hydra.cpp.syntax.Parameter" - -_Parameter_type = Core.Name "type" - -_Parameter_name = Core.Name "name" - -_Parameter_unnamed = Core.Name "unnamed" - -_Parameter_defaultValue = Core.Name "defaultValue" - --- | A std::visit-style pattern match: a visitor applied to a variant expression -data PatternMatch = - PatternMatch { - patternMatchVisitor :: Visitor, - patternMatchVariant :: Expression} - deriving (Eq, Ord, Read, Show) - -_PatternMatch = Core.Name "hydra.cpp.syntax.PatternMatch" - -_PatternMatch_visitor = Core.Name "visitor" - -_PatternMatch_variant = Core.Name "variant" - --- | A C++ pointer member access expression (pointer->member) -data PointerMemberAccessOperation = - PointerMemberAccessOperation { - pointerMemberAccessOperationPointer :: PostfixExpression, - pointerMemberAccessOperationMember :: String} - deriving (Eq, Ord, Read, Show) - -_PointerMemberAccessOperation = Core.Name "hydra.cpp.syntax.PointerMemberAccessOperation" - -_PointerMemberAccessOperation_pointer = Core.Name "pointer" - -_PointerMemberAccessOperation_member = Core.Name "member" - --- | A C++ postfix-expression: a primary expression optionally followed by a postfix operation -data PostfixExpression = - PostfixExpressionPrimary PrimaryExpression | - PostfixExpressionSubscript SubscriptOperation | - PostfixExpressionFunctionCall FunctionCallOperation | - PostfixExpressionTemplateFunctionCall TemplateFunctionCallOperation | - PostfixExpressionMemberAccess MemberAccessOperation | - PostfixExpressionPointerMemberAccess PointerMemberAccessOperation | - PostfixExpressionPostIncrement PostfixExpression | - PostfixExpressionPostDecrement PostfixExpression - deriving (Eq, Ord, Read, Show) - -_PostfixExpression = Core.Name "hydra.cpp.syntax.PostfixExpression" - -_PostfixExpression_primary = Core.Name "primary" - -_PostfixExpression_subscript = Core.Name "subscript" - -_PostfixExpression_functionCall = Core.Name "functionCall" - -_PostfixExpression_templateFunctionCall = Core.Name "templateFunctionCall" - -_PostfixExpression_memberAccess = Core.Name "memberAccess" - -_PostfixExpression_pointerMemberAccess = Core.Name "pointerMemberAccess" - -_PostfixExpression_postIncrement = Core.Name "postIncrement" - -_PostfixExpression_postDecrement = Core.Name "postDecrement" - --- | A C preprocessor #pragma directive -data PragmaDirective = - PragmaDirective { - pragmaDirectiveContent :: String} - deriving (Eq, Ord, Read, Show) - -_PragmaDirective = Core.Name "hydra.cpp.syntax.PragmaDirective" - -_PragmaDirective_content = Core.Name "content" - --- | A C preprocessor directive -data PreprocessorDirective = - PreprocessorDirectiveInclude IncludeDirective | - PreprocessorDirectivePragma PragmaDirective | - PreprocessorDirectiveDefine DefineDirective | - PreprocessorDirectiveUndef UndefDirective | - PreprocessorDirectiveIfdef IfdefDirective | - PreprocessorDirectiveIfndef IfndefDirective | - PreprocessorDirectiveIf IfDirective | - PreprocessorDirectiveElif ElifDirective | - PreprocessorDirectiveElse ElseDirective | - PreprocessorDirectiveEndif EndifDirective | - PreprocessorDirectiveLine LineDirective | - PreprocessorDirectiveError ErrorDirective | - PreprocessorDirectiveWarning WarningDirective - deriving (Eq, Ord, Read, Show) - -_PreprocessorDirective = Core.Name "hydra.cpp.syntax.PreprocessorDirective" - -_PreprocessorDirective_include = Core.Name "include" - -_PreprocessorDirective_pragma = Core.Name "pragma" - -_PreprocessorDirective_define = Core.Name "define" - -_PreprocessorDirective_undef = Core.Name "undef" - -_PreprocessorDirective_ifdef = Core.Name "ifdef" - -_PreprocessorDirective_ifndef = Core.Name "ifndef" - -_PreprocessorDirective_if = Core.Name "if" - -_PreprocessorDirective_elif = Core.Name "elif" - -_PreprocessorDirective_else = Core.Name "else" - -_PreprocessorDirective_endif = Core.Name "endif" - -_PreprocessorDirective_line = Core.Name "line" - -_PreprocessorDirective_error = Core.Name "error" - -_PreprocessorDirective_warning = Core.Name "warning" - --- | A C++ primary-expression: an identifier, a literal, a parenthesized expression, or a lambda -data PrimaryExpression = - PrimaryExpressionIdentifier String | - PrimaryExpressionLiteral Literal | - PrimaryExpressionParenthesized Expression | - PrimaryExpressionLambda LambdaExpression - deriving (Eq, Ord, Read, Show) - -_PrimaryExpression = Core.Name "hydra.cpp.syntax.PrimaryExpression" - -_PrimaryExpression_identifier = Core.Name "identifier" - -_PrimaryExpression_literal = Core.Name "literal" - -_PrimaryExpression_parenthesized = Core.Name "parenthesized" - -_PrimaryExpression_lambda = Core.Name "lambda" - --- | A declaration of a product type as a C++ struct with named fields -data ProductDeclaration = - ProductDeclaration { - productDeclarationName :: String, - productDeclarationFields :: [VariableDeclaration]} - deriving (Eq, Ord, Read, Show) - -_ProductDeclaration = Core.Name "hydra.cpp.syntax.ProductDeclaration" - -_ProductDeclaration_name = Core.Name "name" - -_ProductDeclaration_fields = Core.Name "fields" - --- | A complete C++ source or header file: preprocessor directives, includes, and declarations -data Program = - Program { - programPreprocessorDirectives :: [PreprocessorDirective], - programIncludes :: [IncludeDirective], - programDeclarations :: [Declaration]} - deriving (Eq, Ord, Read, Show) - -_Program = Core.Name "hydra.cpp.syntax.Program" - -_Program_preprocessorDirectives = Core.Name "preprocessorDirectives" - -_Program_includes = Core.Name "includes" - -_Program_declarations = Core.Name "declarations" - --- | A C++ namespace-qualified identifier (namespace::name) -data QualifiedIdentifier = - QualifiedIdentifier { - qualifiedIdentifierNamespace :: String, - qualifiedIdentifierName :: String} - deriving (Eq, Ord, Read, Show) - -_QualifiedIdentifier = Core.Name "hydra.cpp.syntax.QualifiedIdentifier" - -_QualifiedIdentifier_namespace = Core.Name "namespace" - -_QualifiedIdentifier_name = Core.Name "name" - --- | A C++ type expression qualified by const, a reference, or a pointer -data QualifiedType = - QualifiedType { - qualifiedTypeBaseType :: TypeExpression, - qualifiedTypeQualifier :: TypeQualifier} - deriving (Eq, Ord, Read, Show) - -_QualifiedType = Core.Name "hydra.cpp.syntax.QualifiedType" - -_QualifiedType_baseType = Core.Name "baseType" - -_QualifiedType_qualifier = Core.Name "qualifier" - --- | A C++ range-based for statement -data RangeForStatement = - RangeForStatement { - rangeForStatementType :: TypeExpression, - rangeForStatementVariable :: String, - rangeForStatementRange :: Expression, - rangeForStatementBody :: Statement} - deriving (Eq, Ord, Read, Show) - -_RangeForStatement = Core.Name "hydra.cpp.syntax.RangeForStatement" - -_RangeForStatement_type = Core.Name "type" - -_RangeForStatement_variable = Core.Name "variable" - -_RangeForStatement_range = Core.Name "range" - -_RangeForStatement_body = Core.Name "body" - --- | A C++ relational-expression: a shift expression or a relational comparison -data RelationalExpression = - RelationalExpressionShift ShiftExpression | - RelationalExpressionLess LessOperation | - RelationalExpressionGreater GreaterOperation | - RelationalExpressionLessEqual LessEqualOperation | - RelationalExpressionGreaterEqual GreaterEqualOperation - deriving (Eq, Ord, Read, Show) - -_RelationalExpression = Core.Name "hydra.cpp.syntax.RelationalExpression" - -_RelationalExpression_shift = Core.Name "shift" - -_RelationalExpression_less = Core.Name "less" - -_RelationalExpression_greater = Core.Name "greater" - -_RelationalExpression_lessEqual = Core.Name "lessEqual" - -_RelationalExpression_greaterEqual = Core.Name "greaterEqual" - --- | A C++ right shift expression (left >> right) -data RightShiftOperation = - RightShiftOperation { - rightShiftOperationLeft :: ShiftExpression, - rightShiftOperationRight :: AdditiveExpression} - deriving (Eq, Ord, Read, Show) - -_RightShiftOperation = Core.Name "hydra.cpp.syntax.RightShiftOperation" - -_RightShiftOperation_left = Core.Name "left" - -_RightShiftOperation_right = Core.Name "right" - --- | A C++ if statement, with an optional else branch -data SelectionStatement = - SelectionStatement { - selectionStatementCondition :: Expression, - selectionStatementThenBranch :: Statement, - selectionStatementElseBranch :: (Maybe Statement)} - deriving (Eq, Ord, Read, Show) - -_SelectionStatement = Core.Name "hydra.cpp.syntax.SelectionStatement" - -_SelectionStatement_condition = Core.Name "condition" - -_SelectionStatement_thenBranch = Core.Name "thenBranch" - -_SelectionStatement_elseBranch = Core.Name "elseBranch" - --- | A C++ std::set literal, with an element type and elements -data Set = - Set { - setElementType :: TypeExpression, - setElements :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_Set = Core.Name "hydra.cpp.syntax.Set" - -_Set_elementType = Core.Name "elementType" - -_Set_elements = Core.Name "elements" - --- | A declaration of a named std::set type alias -data SetDeclaration = - SetDeclaration { - setDeclarationElementType :: TypeExpression, - setDeclarationName :: String} - deriving (Eq, Ord, Read, Show) - -_SetDeclaration = Core.Name "hydra.cpp.syntax.SetDeclaration" - -_SetDeclaration_elementType = Core.Name "elementType" - -_SetDeclaration_name = Core.Name "name" - --- | A C++ shift-expression: an additive expression, a left shift, or a right shift -data ShiftExpression = - ShiftExpressionAdditive AdditiveExpression | - ShiftExpressionLeftShift LeftShiftOperation | - ShiftExpressionRightShift RightShiftOperation - deriving (Eq, Ord, Read, Show) - -_ShiftExpression = Core.Name "hydra.cpp.syntax.ShiftExpression" - -_ShiftExpression_additive = Core.Name "additive" - -_ShiftExpression_leftShift = Core.Name "leftShift" - -_ShiftExpression_rightShift = Core.Name "rightShift" - --- | A C++ sizeof expression applied to a type -newtype SizeofExpression = - SizeofExpression { - unSizeofExpression :: TypeExpression} - deriving (Eq, Ord, Read, Show) - -_SizeofExpression = Core.Name "hydra.cpp.syntax.SizeofExpression" - --- | A C++ statement -data Statement = - StatementLabeled LabeledStatement | - StatementCompound CompoundStatement | - StatementSelection SelectionStatement | - StatementSwitch SwitchStatement | - StatementIteration IterationStatement | - StatementJump JumpStatement | - StatementDeclaration VariableDeclaration | - StatementExpression Expression - deriving (Eq, Ord, Read, Show) - -_Statement = Core.Name "hydra.cpp.syntax.Statement" - -_Statement_labeled = Core.Name "labeled" - -_Statement_compound = Core.Name "compound" - -_Statement_selection = Core.Name "selection" - -_Statement_switch = Core.Name "switch" - -_Statement_iteration = Core.Name "iteration" - -_Statement_jump = Core.Name "jump" - -_Statement_declaration = Core.Name "declaration" - -_Statement_expression = Core.Name "expression" - --- | A C++ string literal -newtype StringLiteral = - StringLiteral { - unStringLiteral :: String} - deriving (Eq, Ord, Read, Show) - -_StringLiteral = Core.Name "hydra.cpp.syntax.StringLiteral" - --- | A C++ array subscript expression (array[index]) -data SubscriptOperation = - SubscriptOperation { - subscriptOperationArray :: PostfixExpression, - subscriptOperationIndex :: Expression} - deriving (Eq, Ord, Read, Show) - -_SubscriptOperation = Core.Name "hydra.cpp.syntax.SubscriptOperation" - -_SubscriptOperation_array = Core.Name "array" - -_SubscriptOperation_index = Core.Name "index" - --- | A C++ subtraction expression (left - right) -data SubtractOperation = - SubtractOperation { - subtractOperationLeft :: AdditiveExpression, - subtractOperationRight :: MultiplicativeExpression} - deriving (Eq, Ord, Read, Show) - -_SubtractOperation = Core.Name "hydra.cpp.syntax.SubtractOperation" - -_SubtractOperation_left = Core.Name "left" - -_SubtractOperation_right = Core.Name "right" - --- | A C++ switch statement -data SwitchStatement = - SwitchStatement { - switchStatementValue :: Expression, - switchStatementCases :: [CaseStatement]} - deriving (Eq, Ord, Read, Show) - -_SwitchStatement = Core.Name "hydra.cpp.syntax.SwitchStatement" - -_SwitchStatement_value = Core.Name "value" - -_SwitchStatement_cases = Core.Name "cases" - --- | A single argument to a C++ template instantiation: a type or a value -data TemplateArgument = - TemplateArgumentType TypeExpression | - TemplateArgumentValue Expression - deriving (Eq, Ord, Read, Show) - -_TemplateArgument = Core.Name "hydra.cpp.syntax.TemplateArgument" - -_TemplateArgument_type = Core.Name "type" - -_TemplateArgument_value = Core.Name "value" - --- | A C++ template declaration wrapping a class or function declaration -data TemplateDeclaration = - TemplateDeclaration { - templateDeclarationInline :: Bool, - templateDeclarationParameters :: [String], - templateDeclarationDeclaration :: Declaration} - deriving (Eq, Ord, Read, Show) - -_TemplateDeclaration = Core.Name "hydra.cpp.syntax.TemplateDeclaration" - -_TemplateDeclaration_inline = Core.Name "inline" - -_TemplateDeclaration_parameters = Core.Name "parameters" - -_TemplateDeclaration_declaration = Core.Name "declaration" - --- | A C++ explicit template function call (func(arguments)) -data TemplateFunctionCallOperation = - TemplateFunctionCallOperation { - templateFunctionCallOperationFunction :: PostfixExpression, - templateFunctionCallOperationTemplateArguments :: [TemplateArgument], - templateFunctionCallOperationArguments :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_TemplateFunctionCallOperation = Core.Name "hydra.cpp.syntax.TemplateFunctionCallOperation" - -_TemplateFunctionCallOperation_function = Core.Name "function" - -_TemplateFunctionCallOperation_templateArguments = Core.Name "templateArguments" - -_TemplateFunctionCallOperation_arguments = Core.Name "arguments" - --- | A C++ template instantiation type (e.g. std::vector) -data TemplateType = - TemplateType { - templateTypeName :: String, - templateTypeArguments :: [TemplateArgument]} - deriving (Eq, Ord, Read, Show) - -_TemplateType = Core.Name "hydra.cpp.syntax.TemplateType" - -_TemplateType_name = Core.Name "name" - -_TemplateType_arguments = Core.Name "arguments" - --- | A C++ ternary conditional expression (condition ? trueExpr : falseExpr) -data TernaryExpression = - TernaryExpression { - ternaryExpressionCondition :: LogicalOrExpression, - ternaryExpressionTrueExpr :: Expression, - ternaryExpressionFalseExpr :: ConditionalExpression} - deriving (Eq, Ord, Read, Show) - -_TernaryExpression = Core.Name "hydra.cpp.syntax.TernaryExpression" - -_TernaryExpression_condition = Core.Name "condition" - -_TernaryExpression_trueExpr = Core.Name "trueExpr" - -_TernaryExpression_falseExpr = Core.Name "falseExpr" - --- | A C++ type expression -data TypeExpression = - TypeExpressionBasic BasicType | - TypeExpressionQualified QualifiedType | - TypeExpressionTemplate TemplateType | - TypeExpressionFunction FunctionType | - TypeExpressionAuto - deriving (Eq, Ord, Read, Show) - -_TypeExpression = Core.Name "hydra.cpp.syntax.TypeExpression" - -_TypeExpression_basic = Core.Name "basic" - -_TypeExpression_qualified = Core.Name "qualified" - -_TypeExpression_template = Core.Name "template" - -_TypeExpression_function = Core.Name "function" - -_TypeExpression_auto = Core.Name "auto" - --- | A C++ type qualifier: const, lvalue reference, rvalue reference, or pointer -data TypeQualifier = - TypeQualifierConst | - TypeQualifierLvalueRef | - TypeQualifierRvalueRef | - TypeQualifierPointer - deriving (Eq, Ord, Read, Show) - -_TypeQualifier = Core.Name "hydra.cpp.syntax.TypeQualifier" - -_TypeQualifier_const = Core.Name "const" - -_TypeQualifier_lvalueRef = Core.Name "lvalueRef" - -_TypeQualifier_rvalueRef = Core.Name "rvalueRef" - -_TypeQualifier_pointer = Core.Name "pointer" - --- | A C++ typedef or using type alias declaration -data TypedefDeclaration = - TypedefDeclaration { - typedefDeclarationName :: String, - typedefDeclarationType :: TypeExpression, - typedefDeclarationIsUsing :: Bool} - deriving (Eq, Ord, Read, Show) - -_TypedefDeclaration = Core.Name "hydra.cpp.syntax.TypedefDeclaration" - -_TypedefDeclaration_name = Core.Name "name" - -_TypedefDeclaration_type = Core.Name "type" - -_TypedefDeclaration_isUsing = Core.Name "isUsing" - --- | A C++ unary-expression: a postfix expression, a unary operation, or a sizeof expression -data UnaryExpression = - UnaryExpressionPostfix PostfixExpression | - UnaryExpressionUnaryOp UnaryOperation | - UnaryExpressionSizeof SizeofExpression - deriving (Eq, Ord, Read, Show) - -_UnaryExpression = Core.Name "hydra.cpp.syntax.UnaryExpression" - -_UnaryExpression_postfix = Core.Name "postfix" - -_UnaryExpression_unaryOp = Core.Name "unaryOp" - -_UnaryExpression_sizeof = Core.Name "sizeof" - --- | A C++ unary operation applied to an operand (e.g. -x, !x, *x) -data UnaryOperation = - UnaryOperation { - unaryOperationOperator :: UnaryOperator, - unaryOperationOperand :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_UnaryOperation = Core.Name "hydra.cpp.syntax.UnaryOperation" - -_UnaryOperation_operator = Core.Name "operator" - -_UnaryOperation_operand = Core.Name "operand" - --- | A C++ unary operator -data UnaryOperator = - UnaryOperatorPlus | - UnaryOperatorMinus | - UnaryOperatorLogicalNot | - UnaryOperatorBitwiseNot | - UnaryOperatorDereference | - UnaryOperatorAddressOf | - UnaryOperatorPreIncrement | - UnaryOperatorPreDecrement - deriving (Eq, Ord, Read, Show) - -_UnaryOperator = Core.Name "hydra.cpp.syntax.UnaryOperator" - -_UnaryOperator_plus = Core.Name "plus" - -_UnaryOperator_minus = Core.Name "minus" - -_UnaryOperator_logicalNot = Core.Name "logicalNot" - -_UnaryOperator_bitwiseNot = Core.Name "bitwiseNot" - -_UnaryOperator_dereference = Core.Name "dereference" - -_UnaryOperator_addressOf = Core.Name "addressOf" - -_UnaryOperator_preIncrement = Core.Name "preIncrement" - -_UnaryOperator_preDecrement = Core.Name "preDecrement" - --- | A C preprocessor #undef directive -data UndefDirective = - UndefDirective { - undefDirectiveName :: String} - deriving (Eq, Ord, Read, Show) - -_UndefDirective = Core.Name "hydra.cpp.syntax.UndefDirective" - -_UndefDirective_name = Core.Name "name" - --- | A C++ variable declaration, with an optional type (for auto) and initializer -data VariableDeclaration = - VariableDeclaration { - variableDeclarationType :: (Maybe TypeExpression), - variableDeclarationName :: String, - variableDeclarationInitializer :: (Maybe Expression), - variableDeclarationIsAuto :: Bool} - deriving (Eq, Ord, Read, Show) - -_VariableDeclaration = Core.Name "hydra.cpp.syntax.VariableDeclaration" - -_VariableDeclaration_type = Core.Name "type" - -_VariableDeclaration_name = Core.Name "name" - -_VariableDeclaration_initializer = Core.Name "initializer" - -_VariableDeclaration_isAuto = Core.Name "isAuto" - --- | A declaration of a named std::variant type alias over a list of member types -data VariantDeclaration = - VariantDeclaration { - variantDeclarationTypes :: [TypeExpression], - variantDeclarationName :: String} - deriving (Eq, Ord, Read, Show) - -_VariantDeclaration = Core.Name "hydra.cpp.syntax.VariantDeclaration" - -_VariantDeclaration_types = Core.Name "types" - -_VariantDeclaration_name = Core.Name "name" - --- | A C++ std::vector literal, with an element type and elements -data Vector = - Vector { - vectorElementType :: TypeExpression, - vectorElements :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_Vector = Core.Name "hydra.cpp.syntax.Vector" - -_Vector_elementType = Core.Name "elementType" - -_Vector_elements = Core.Name "elements" - --- | A C++ visitor used in a pattern match: a single lambda or a set of overloaded lambdas -data Visitor = - VisitorLambda LambdaExpression | - VisitorOverloaded OverloadedLambdas - deriving (Eq, Ord, Read, Show) - -_Visitor = Core.Name "hydra.cpp.syntax.Visitor" - -_Visitor_lambda = Core.Name "lambda" - -_Visitor_overloaded = Core.Name "overloaded" - --- | A C preprocessor #warning directive -data WarningDirective = - WarningDirective { - warningDirectiveMessage :: String} - deriving (Eq, Ord, Read, Show) - -_WarningDirective = Core.Name "hydra.cpp.syntax.WarningDirective" - -_WarningDirective_message = Core.Name "message" - --- | A C++ while statement -data WhileStatement = - WhileStatement { - whileStatementCondition :: Expression, - whileStatementBody :: Statement} - deriving (Eq, Ord, Read, Show) - -_WhileStatement = Core.Name "hydra.cpp.syntax.WhileStatement" - -_WhileStatement_condition = Core.Name "condition" - -_WhileStatement_body = Core.Name "body" diff --git a/src/main/haskell/Hydra/Cpp/Utils.hs b/src/main/haskell/Hydra/Cpp/Utils.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Cpp/Utils.hs +++ /dev/null @@ -1,308 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | C++ utilities for constructing C++ syntax trees - -module Hydra.Cpp.Utils where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Cpp.Syntax as Syntax -import qualified Hydra.Docs as Docs -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Create a const reference parameter -constParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter -constParameter name typ = - Syntax.Parameter { - Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = typ, - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), - Syntax.parameterName = name, - Syntax.parameterUnnamed = False, - Syntax.parameterDefaultValue = Nothing} - --- | Create a C++ class declaration -cppClassDeclaration :: String -> [Syntax.BaseSpecifier] -> Maybe Syntax.ClassBody -> Syntax.Declaration -cppClassDeclaration name baseSpecs mbody = - Syntax.DeclarationClass (Syntax.ClassDeclaration { - Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { - Syntax.classSpecifierKey = Syntax.ClassKeyClass, - Syntax.classSpecifierName = name, - Syntax.classSpecifierInheritance = baseSpecs}, - Syntax.classDeclarationBody = mbody}) - --- | Create a C++ enum class declaration -cppEnumDeclaration :: String -> Maybe Syntax.ClassBody -> Syntax.Declaration -cppEnumDeclaration name mbody = - Syntax.DeclarationClass (Syntax.ClassDeclaration { - Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { - Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, - Syntax.classSpecifierName = name, - Syntax.classSpecifierInheritance = []}, - Syntax.classDeclarationBody = mbody}) - --- | Create a C++ enum class forward declaration -cppEnumForwardDeclaration :: String -> Syntax.Declaration -cppEnumForwardDeclaration name = - Syntax.DeclarationClass (Syntax.ClassDeclaration { - Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { - Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, - Syntax.classSpecifierName = name, - Syntax.classSpecifierInheritance = []}, - Syntax.classDeclarationBody = Nothing}) - --- | Convert a PostfixExpression to an Expression -cppPostfixExpressionToCppExpression :: Syntax.PostfixExpression -> Syntax.Expression -cppPostfixExpressionToCppExpression pf = cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionPostfix pf) - --- | Convert a PrimaryExpression to an Expression -cppPrimaryExpressionToCppExpression :: Syntax.PrimaryExpression -> Syntax.Expression -cppPrimaryExpressionToCppExpression prim = cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary prim) - --- | Convert a UnaryExpression to an Expression -cppUnaryExpressionToCppExpression :: Syntax.UnaryExpression -> Syntax.Expression -cppUnaryExpressionToCppExpression ue = - Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression ue))) - --- | Convert a UnaryExpression to a LogicalOrExpression -cppUnaryExpressionToCppLogicalOrExpression :: Syntax.UnaryExpression -> Syntax.LogicalOrExpression -cppUnaryExpressionToCppLogicalOrExpression ue = - Syntax.LogicalOrExpressionLogicalAnd (Syntax.LogicalAndExpressionInclusiveOr (Syntax.InclusiveOrExpressionExclusiveOr (Syntax.ExclusiveOrExpressionAnd (Syntax.AndExpressionEquality (Syntax.EqualityExpressionRelational (Syntax.RelationalExpressionShift (Syntax.ShiftExpressionAdditive (Syntax.AdditiveExpressionMultiplicative (Syntax.MultiplicativeExpressionUnary ue))))))))) - --- | Create a cast expression -createCastExpr :: t0 -> Syntax.Expression -> Syntax.Expression -createCastExpr targetType expr = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized (cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized expr))) - --- | Create a compound statement -createCompoundStmt :: [Syntax.Statement] -> Syntax.CompoundStatement -createCompoundStmt stmts = Syntax.CompoundStatement stmts - --- | Create a const reference type -createConstRefType :: Syntax.TypeExpression -> Syntax.TypeExpression -createConstRefType baseType = createReferenceType (createConstType baseType) - --- | Create a const-qualified type -createConstType :: Syntax.TypeExpression -> Syntax.TypeExpression -createConstType baseType = createQualifiedType baseType Syntax.TypeQualifierConst - --- | Create a constructor body (default if no params, empty otherwise) -createConstructorBody :: [t0] -> Syntax.FunctionBody -createConstructorBody params = Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault emptyFunctionBody - --- | Create an enum access expression -createEnumAccessExpr :: String -> String -> Syntax.Expression -createEnumAccessExpr enumName valueName = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { - Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier enumName)), - Syntax.memberAccessOperationMember = valueName})) - --- | Create a function call expression -createFunctionCallExpr :: String -> [Syntax.Expression] -> Syntax.Expression -createFunctionCallExpr funcName args = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier funcName)), - Syntax.functionCallOperationArguments = args})) - --- | Create a header file with pragma once -createHeaderFile :: [Syntax.IncludeDirective] -> [Syntax.Declaration] -> Syntax.Program -createHeaderFile includes decls = - Syntax.Program { - Syntax.programPreprocessorDirectives = [ - Syntax.PreprocessorDirectivePragma (Syntax.PragmaDirective { - Syntax.pragmaDirectiveContent = "once"})], - Syntax.programIncludes = includes, - Syntax.programDeclarations = decls} - --- | Create an identifier expression -createIdentifierExpr :: String -> Syntax.Expression -createIdentifierExpr name = cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier name) - --- | Create a lambda expression -createLambdaExpr :: [Syntax.Parameter] -> Syntax.Expression -> Syntax.Expression -createLambdaExpr params body = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionLambda (Syntax.LambdaExpression { - Syntax.lambdaExpressionCaptures = (Syntax.CaptureListCaptures []), - Syntax.lambdaExpressionParameters = params, - Syntax.lambdaExpressionReturnType = Nothing, - Syntax.lambdaExpressionBody = (Syntax.CompoundStatement [ - Syntax.StatementExpression body])}))) - --- | Create a boolean literal expression -createLiteralBoolExpr :: Bool -> Syntax.Expression -createLiteralBoolExpr val = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralBoolean (Syntax.BooleanLiteral val))) - --- | Create an integer literal expression -createLiteralIntExpr :: Integer -> Syntax.Expression -createLiteralIntExpr val = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteralDecimal val))) - --- | Create a string literal expression -createLiteralStringExpr :: String -> Syntax.Expression -createLiteralStringExpr val = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralString (Syntax.StringLiteral val))) - --- | Create a member access expression -createMemberAccessExpr :: Syntax.Expression -> String -> Syntax.Expression -createMemberAccessExpr objExpr member = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { - Syntax.memberAccessOperationObject = (extractPostfixExpression objExpr), - Syntax.memberAccessOperationMember = member})) - --- | Create a qualified type with a qualifier -createQualifiedType :: Syntax.TypeExpression -> Syntax.TypeQualifier -> Syntax.TypeExpression -createQualifiedType baseType qualifier = - Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = baseType, - Syntax.qualifiedTypeQualifier = qualifier}) - --- | Create a reference type -createReferenceType :: Syntax.TypeExpression -> Syntax.TypeExpression -createReferenceType baseType = createQualifiedType baseType Syntax.TypeQualifierLvalueRef - --- | Create a return statement with a value -createReturnStmt :: Syntax.Expression -> Syntax.Statement -createReturnStmt expr = Syntax.StatementJump (Syntax.JumpStatementReturnValue expr) - --- | Create a void return statement -createReturnVoidStmt :: Syntax.Statement -createReturnVoidStmt = Syntax.StatementJump Syntax.JumpStatementReturnVoid - --- | Create a template type -createTemplateType :: String -> [Syntax.TypeExpression] -> Syntax.TypeExpression -createTemplateType name args = - Syntax.TypeExpressionTemplate (Syntax.TemplateType { - Syntax.templateTypeName = name, - Syntax.templateTypeArguments = (Lists.map (\a -> Syntax.TemplateArgumentType a) args)}) - --- | Create a *this expression -createThisExpr :: Syntax.Expression -createThisExpr = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "*this")) - --- | Create a throw statement -createThrowStmt :: String -> Syntax.Expression -> Syntax.Statement -createThrowStmt exceptionType arg = - Syntax.StatementJump (Syntax.JumpStatementThrow (createFunctionCallExpr exceptionType [ - arg])) - --- | Create a typeid(...).name() call expression -createTypeIdNameCall :: Syntax.Expression -createTypeIdNameCall = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { - Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { - Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "typeid")), - Syntax.functionCallOperationArguments = [ - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized createThisExpr)]})), - Syntax.memberAccessOperationMember = "name"})), - Syntax.functionCallOperationArguments = []})) - --- | Create a type name expression -createTypeNameExpr :: String -> Syntax.Expression -createTypeNameExpr typeName = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier typeName)) - --- | Create a variant expression -createVariantExpr :: Syntax.Expression -createVariantExpr = - cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "variant")) - --- | An empty function body -emptyFunctionBody :: Syntax.FunctionBody -emptyFunctionBody = Syntax.FunctionBodyCompound (Syntax.CompoundStatement []) - --- | Extract the PostfixExpression from a fully-wrapped Expression -extractPostfixExpression :: Syntax.Expression -> Syntax.PostfixExpression -extractPostfixExpression expr = - case expr of - Syntax.ExpressionAssignment v0 -> case v0 of - Syntax.AssignmentExpressionConditional v1 -> case v1 of - Syntax.ConditionalExpressionLogicalOr v2 -> case v2 of - Syntax.LogicalOrExpressionLogicalAnd v3 -> case v3 of - Syntax.LogicalAndExpressionInclusiveOr v4 -> case v4 of - Syntax.InclusiveOrExpressionExclusiveOr v5 -> case v5 of - Syntax.ExclusiveOrExpressionAnd v6 -> case v6 of - Syntax.AndExpressionEquality v7 -> case v7 of - Syntax.EqualityExpressionRelational v8 -> case v8 of - Syntax.RelationalExpressionShift v9 -> case v9 of - Syntax.ShiftExpressionAdditive v10 -> case v10 of - Syntax.AdditiveExpressionMultiplicative v11 -> case v11 of - Syntax.MultiplicativeExpressionUnary v12 -> case v12 of - Syntax.UnaryExpressionPostfix v13 -> v13 - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") - --- | Protected access specifier member specification -memberSpecificationProtected :: Syntax.MemberSpecification -memberSpecificationProtected = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierProtected - --- | Public access specifier member specification -memberSpecificationPublic :: Syntax.MemberSpecification -memberSpecificationPublic = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierPublic - --- | Create a string expression -stringExpression :: String -> Syntax.Expression -stringExpression s = - cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralString (Syntax.StringLiteral s))) - --- | Add const qualifier to a type -toConstType :: Syntax.TypeExpression -> Syntax.TypeExpression -toConstType baseType = - Syntax.TypeExpressionQualified (Syntax.QualifiedType { - Syntax.qualifiedTypeBaseType = baseType, - Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst}) - --- | Create an unnamed parameter -unnamedParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter -unnamedParameter name typ = - Syntax.Parameter { - Syntax.parameterType = typ, - Syntax.parameterName = name, - Syntax.parameterUnnamed = True, - Syntax.parameterDefaultValue = Nothing} diff --git a/src/main/haskell/Hydra/Csharp/Language.hs b/src/main/haskell/Hydra/Csharp/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Csharp/Language.hs +++ /dev/null @@ -1,247 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints and reserved words for C Sharp (C#) - -module Hydra.Csharp.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | Language constraints for C Sharp (C#) -csharpLanguage :: Coders.Language -csharpLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.csharp"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "cs")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt8, - Core.IntegerTypeInt16, - Core.IntegerTypeInt32, - Core.IntegerTypeInt64, - Core.IntegerTypeUint8, - Core.IntegerTypeUint16, - Core.IntegerTypeUint32, - Core.IntegerTypeUint64] - termVariants = - Sets.fromList [ - Variants.TermVariantApplication, - Variants.TermVariantCases, - Variants.TermVariantLambda, - Variants.TermVariantProject, - Variants.TermVariantUnwrap, - Variants.TermVariantTypeApplication, - Variants.TermVariantTypeLambda, - Variants.TermVariantLet, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantInject, - Variants.TermVariantVariable, - Variants.TermVariantWrap] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantApplication, - Variants.TypeVariantFunction, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantVariable, - Variants.TypeVariantWrap] - typePredicate = \_ -> True - --- | A set of reserved words in C#. Both the "keywords" and "contextual keywords" are drawn from section 6.4.4 of the C# documentation: --- | https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#64-tokens -csharpReservedWords :: S.Set String -csharpReservedWords = - Sets.fromList (Lists.concat [ - keywords, - contextualKeywords]) - where - keywords = - [ - "DEFAULT", - "FALSE", - "NULL", - "TRUE", - "abstract", - "as", - "base", - "bool", - "break", - "byte", - "case", - "catch", - "char", - "checked", - "class", - "const", - "continue", - "decimal", - "delegate", - "do", - "double", - "else", - "enum", - "event", - "explicit", - "extern", - "finally", - "fixed", - "float", - "for", - "foreach", - "goto", - "if", - "implicit", - "in", - "int", - "interface", - "internal", - "is", - "lock", - "long", - "namespace", - "new", - "object", - "operator", - "out", - "override", - "params", - "private", - "protected", - "public", - "readonly", - "ref", - "return", - "sbyte", - "sealed", - "short", - "sizeof", - "stackalloc", - "static", - "string", - "struct", - "switch", - "this", - "throw", - "try", - "typeof", - "uint", - "ulong", - "unchecked", - "unsafe", - "ushort", - "using", - "virtual", - "void", - "volatile", - "while"] - contextualKeywords = - [ - "add", - "alias", - "ascending", - "async", - "await", - "by", - "descending", - "dynamic", - "equals", - "from", - "get", - "global", - "group", - "into", - "join", - "let", - "nameof", - "on", - "orderby", - "partial", - "remove", - "select", - "set", - "unmanaged", - "value", - "var", - "when", - "where", - "yield"] diff --git a/src/main/haskell/Hydra/Csharp/Syntax.hs b/src/main/haskell/Hydra/Csharp/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Csharp/Syntax.hs +++ /dev/null @@ -1,5297 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A C# syntax module based on the ANTLR grammar dated 02/07/2024 and available at: --- | https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/grammar - -module Hydra.Csharp.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | The body of a property or indexer accessor: a block, an expression, or empty (abstract). -data AccessorBody = - AccessorBodyBlock Block | - AccessorBodyExpression Expression | - AccessorBodyEmpty - deriving (Eq, Ord, Read, Show) - -_AccessorBody = Core.Name "hydra.csharp.syntax.AccessorBody" - -_AccessorBody_block = Core.Name "block" - -_AccessorBody_expression = Core.Name "expression" - -_AccessorBody_empty = Core.Name "empty" - --- | A single get or set accessor, with optional attributes and an access modifier. -data AccessorDeclaration = - AccessorDeclaration { - accessorDeclarationAttributes :: (Maybe Attributes), - accessorDeclarationModifier :: (Maybe AccessorModifier), - accessorDeclarationBody :: AccessorBody} - deriving (Eq, Ord, Read, Show) - -_AccessorDeclaration = Core.Name "hydra.csharp.syntax.AccessorDeclaration" - -_AccessorDeclaration_attributes = Core.Name "attributes" - -_AccessorDeclaration_modifier = Core.Name "modifier" - -_AccessorDeclaration_body = Core.Name "body" - --- | The get and/or set accessors of a standard (non-ref-returning) property. -data AccessorDeclarations = - AccessorDeclarationsGet (Maybe AccessorDeclaration) | - AccessorDeclarationsSet (Maybe AccessorDeclaration) - deriving (Eq, Ord, Read, Show) - -_AccessorDeclarations = Core.Name "hydra.csharp.syntax.AccessorDeclarations" - -_AccessorDeclarations_get = Core.Name "get" - -_AccessorDeclarations_set = Core.Name "set" - --- | An access modifier restricting a get or set accessor beyond the property's own accessibility. -data AccessorModifier = - AccessorModifierProtected | - AccessorModifierInternal | - AccessorModifierPrivate | - AccessorModifierProtectedInternal | - AccessorModifierInternalProtected | - AccessorModifierProtectedPrivate | - AccessorModifierPrivateProtected - deriving (Eq, Ord, Read, Show) - -_AccessorModifier = Core.Name "hydra.csharp.syntax.AccessorModifier" - -_AccessorModifier_protected = Core.Name "protected" - -_AccessorModifier_internal = Core.Name "internal" - -_AccessorModifier_private = Core.Name "private" - -_AccessorModifier_protectedInternal = Core.Name "protectedInternal" - -_AccessorModifier_internalProtected = Core.Name "internalProtected" - -_AccessorModifier_protectedPrivate = Core.Name "protectedPrivate" - -_AccessorModifier_privateProtected = Core.Name "privateProtected" - --- | An event declaration using explicit add/remove accessor syntax. -data AccessorsEventDeclaration = - AccessorsEventDeclaration { - accessorsEventDeclarationAttributes :: (Maybe Attributes), - accessorsEventDeclarationModifiers :: [EventModifier], - accessorsEventDeclarationType :: Type, - accessorsEventDeclarationName :: MemberName, - accessorsEventDeclarationAccessors :: EventAccessorDeclarations} - deriving (Eq, Ord, Read, Show) - -_AccessorsEventDeclaration = Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration" - -_AccessorsEventDeclaration_attributes = Core.Name "attributes" - -_AccessorsEventDeclaration_modifiers = Core.Name "modifiers" - -_AccessorsEventDeclaration_type = Core.Name "type" - -_AccessorsEventDeclaration_name = Core.Name "name" - -_AccessorsEventDeclaration_accessors = Core.Name "accessors" - --- | The add or remove accessor body of an event declaration. -data AddRemoveAccessorDeclaration = - AddRemoveAccessorDeclaration { - addRemoveAccessorDeclarationAttributes :: (Maybe Attributes), - addRemoveAccessorDeclarationBody :: Block} - deriving (Eq, Ord, Read, Show) - -_AddRemoveAccessorDeclaration = Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration" - -_AddRemoveAccessorDeclaration_attributes = Core.Name "attributes" - -_AddRemoveAccessorDeclaration_body = Core.Name "body" - --- | A simple multiplicative expression or a binary addition/subtraction expression. -data AdditiveExpression = - AdditiveExpressionSimple MultiplicativeExpression | - AdditiveExpressionBinary BinaryAdditiveExpression - deriving (Eq, Ord, Read, Show) - -_AdditiveExpression = Core.Name "hydra.csharp.syntax.AdditiveExpression" - -_AdditiveExpression_simple = Core.Name "simple" - -_AdditiveExpression_binary = Core.Name "binary" - --- | The plus or minus operator used in an additive expression. -data AdditiveOperator = - AdditiveOperatorPlus | - AdditiveOperatorMinus - deriving (Eq, Ord, Read, Show) - -_AdditiveOperator = Core.Name "hydra.csharp.syntax.AdditiveOperator" - -_AdditiveOperator_plus = Core.Name "plus" - -_AdditiveOperator_minus = Core.Name "minus" - --- | A simple equality expression or a binary bitwise-AND expression. -data AndExpression = - AndExpressionSimple EqualityExpression | - AndExpressionBinary BinaryAndExpression - deriving (Eq, Ord, Read, Show) - -_AndExpression = Core.Name "hydra.csharp.syntax.AndExpression" - -_AndExpression_simple = Core.Name "simple" - -_AndExpression_binary = Core.Name "binary" - --- | The body of an anonymous function: a null-conditional invocation, expression, ref, or block. -data AnonymousFunctionBody = - AnonymousFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression | - AnonymousFunctionBodyExpression Expression | - AnonymousFunctionBodyRef VariableReference | - AnonymousFunctionBodyBlock Block - deriving (Eq, Ord, Read, Show) - -_AnonymousFunctionBody = Core.Name "hydra.csharp.syntax.AnonymousFunctionBody" - -_AnonymousFunctionBody_nullConditionalInvocation = Core.Name "nullConditionalInvocation" - -_AnonymousFunctionBody_expression = Core.Name "expression" - -_AnonymousFunctionBody_ref = Core.Name "ref" - -_AnonymousFunctionBody_block = Core.Name "block" - --- | A ref, out, or in modifier on an explicit anonymous function parameter. -data AnonymousFunctionParameterModifier = - AnonymousFunctionParameterModifierRef | - AnonymousFunctionParameterModifierOut | - AnonymousFunctionParameterModifierIn - deriving (Eq, Ord, Read, Show) - -_AnonymousFunctionParameterModifier = Core.Name "hydra.csharp.syntax.AnonymousFunctionParameterModifier" - -_AnonymousFunctionParameterModifier_ref = Core.Name "ref" - -_AnonymousFunctionParameterModifier_out = Core.Name "out" - -_AnonymousFunctionParameterModifier_in = Core.Name "in" - --- | The parameter list of a lambda expression, either explicitly or implicitly typed. -data AnonymousFunctionSignature = - AnonymousFunctionSignatureExplicit [ExplicitAnonymousFunctionParameter] | - AnonymousFunctionSignatureImplicit [Identifier] - deriving (Eq, Ord, Read, Show) - -_AnonymousFunctionSignature = Core.Name "hydra.csharp.syntax.AnonymousFunctionSignature" - -_AnonymousFunctionSignature_explicit = Core.Name "explicit" - -_AnonymousFunctionSignature_implicit = Core.Name "implicit" - --- | A delegate expression created with the anonymous method syntax (delegate(...) { ... }). -data AnonymousMethodExpression = - AnonymousMethodExpression { - anonymousMethodExpressionAsync :: Bool, - anonymousMethodExpressionSignature :: [ExplicitAnonymousFunctionParameter], - anonymousMethodExpressionBody :: Block} - deriving (Eq, Ord, Read, Show) - -_AnonymousMethodExpression = Core.Name "hydra.csharp.syntax.AnonymousMethodExpression" - -_AnonymousMethodExpression_async = Core.Name "async" - -_AnonymousMethodExpression_signature = Core.Name "signature" - -_AnonymousMethodExpression_body = Core.Name "body" - --- | A single argument in an argument list, with an optional name for named arguments. -data Argument = - Argument { - argumentName :: (Maybe Identifier), - argumentValue :: ArgumentValue} - deriving (Eq, Ord, Read, Show) - -_Argument = Core.Name "hydra.csharp.syntax.Argument" - -_Argument_name = Core.Name "name" - -_Argument_value = Core.Name "value" - --- | A non-empty, comma-separated list of arguments passed to a member or delegate invocation. -newtype ArgumentList = - ArgumentList { - unArgumentList :: [Argument]} - deriving (Eq, Ord, Read, Show) - -_ArgumentList = Core.Name "hydra.csharp.syntax.ArgumentList" - --- | The value portion of an argument: an expression, or a ref/in/out variable reference. -data ArgumentValue = - ArgumentValueExpression Expression | - ArgumentValueIn VariableReference | - ArgumentValueRef VariableReference | - ArgumentValueOut VariableReference - deriving (Eq, Ord, Read, Show) - -_ArgumentValue = Core.Name "hydra.csharp.syntax.ArgumentValue" - -_ArgumentValue_expression = Core.Name "expression" - -_ArgumentValue_in = Core.Name "in" - -_ArgumentValue_ref = Core.Name "ref" - -_ArgumentValue_out = Core.Name "out" - --- | An expression that creates a new array, in any of its three creation-syntax forms. -data ArrayCreationExpression = - ArrayCreationExpressionNonArrayType NonArrayTypeArrayCreationExpression | - ArrayCreationExpressionArrayType ArrayTypeArrayCreationExpression | - ArrayCreationExpressionRankSpecifier RankSpecifierArrayCreationExpression - deriving (Eq, Ord, Read, Show) - -_ArrayCreationExpression = Core.Name "hydra.csharp.syntax.ArrayCreationExpression" - -_ArrayCreationExpression_nonArrayType = Core.Name "nonArrayType" - -_ArrayCreationExpression_arrayType = Core.Name "arrayType" - -_ArrayCreationExpression_rankSpecifier = Core.Name "rankSpecifier" - --- | A brace-delimited list of variable initializers used to populate an array. -newtype ArrayInitializer = - ArrayInitializer { - unArrayInitializer :: [VariableInitializer]} - deriving (Eq, Ord, Read, Show) - -_ArrayInitializer = Core.Name "hydra.csharp.syntax.ArrayInitializer" - --- | An array type formed from a non-array element type and one or more rank specifiers. -data ArrayType = - ArrayType { - arrayTypeType :: NonArrayType, - arrayTypeRank :: [RankSpecifier]} - deriving (Eq, Ord, Read, Show) - -_ArrayType = Core.Name "hydra.csharp.syntax.ArrayType" - -_ArrayType_type = Core.Name "type" - -_ArrayType_rank = Core.Name "rank" - --- | Array creation using an explicit array type together with an array initializer. -data ArrayTypeArrayCreationExpression = - ArrayTypeArrayCreationExpression { - arrayTypeArrayCreationExpressionType :: ArrayType, - arrayTypeArrayCreationExpressionInitializer :: ArrayInitializer} - deriving (Eq, Ord, Read, Show) - -_ArrayTypeArrayCreationExpression = Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression" - -_ArrayTypeArrayCreationExpression_type = Core.Name "type" - -_ArrayTypeArrayCreationExpression_initializer = Core.Name "initializer" - --- | An 'as' expression that attempts a type conversion, yielding null on failure. -data AsTypeExpression = - AsTypeExpression { - asTypeExpressionExpression :: RelationalExpression, - asTypeExpressionType :: Type} - deriving (Eq, Ord, Read, Show) - -_AsTypeExpression = Core.Name "hydra.csharp.syntax.AsTypeExpression" - -_AsTypeExpression_expression = Core.Name "expression" - -_AsTypeExpression_type = Core.Name "type" - --- | An assignment expression: a target, an assignment operator, and a right-hand expression. -data Assignment = - Assignment { - assignmentLeft :: UnaryExpression, - assignmentOperator :: AssignmentOperator, - assignmentRight :: Expression} - deriving (Eq, Ord, Read, Show) - -_Assignment = Core.Name "hydra.csharp.syntax.Assignment" - -_Assignment_left = Core.Name "left" - -_Assignment_operator = Core.Name "operator" - -_Assignment_right = Core.Name "right" - --- | A member declarator of the form 'name = expression' in an anonymous object creation. -data AssignmentMemberDeclarator = - AssignmentMemberDeclarator { - assignmentMemberDeclaratorIdentifier :: Identifier, - assignmentMemberDeclaratorExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_AssignmentMemberDeclarator = Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator" - -_AssignmentMemberDeclarator_identifier = Core.Name "identifier" - -_AssignmentMemberDeclarator_expression = Core.Name "expression" - --- | The simple assignment operator or one of the compound assignment operators. -data AssignmentOperator = - AssignmentOperatorSimple Bool | - AssignmentOperatorPlusEquals | - AssignmentOperatorMinusEquals | - AssignmentOperatorTimesEquals | - AssignmentOperatorDivideEquals | - AssignmentOperatorModEquals | - AssignmentOperatorAndEquals | - AssignmentOperatorOrEquals | - AssignmentOperatorXorEquals | - AssignmentOperatorLeftShiftEquals | - AssignmentOperatorRightShiftEquals - deriving (Eq, Ord, Read, Show) - -_AssignmentOperator = Core.Name "hydra.csharp.syntax.AssignmentOperator" - -_AssignmentOperator_simple = Core.Name "simple" - -_AssignmentOperator_plusEquals = Core.Name "plusEquals" - -_AssignmentOperator_minusEquals = Core.Name "minusEquals" - -_AssignmentOperator_timesEquals = Core.Name "timesEquals" - -_AssignmentOperator_divideEquals = Core.Name "divideEquals" - -_AssignmentOperator_modEquals = Core.Name "modEquals" - -_AssignmentOperator_andEquals = Core.Name "andEquals" - -_AssignmentOperator_orEquals = Core.Name "orEquals" - -_AssignmentOperator_xorEquals = Core.Name "xorEquals" - -_AssignmentOperator_leftShiftEquals = Core.Name "leftShiftEquals" - -_AssignmentOperator_rightShiftEquals = Core.Name "rightShiftEquals" - --- | A single attribute, consisting of an attribute name and optional constructor/named arguments. -data Attribute = - Attribute { - attributeName :: AttributeName, - attributeArguments :: (Maybe AttributeArguments)} - deriving (Eq, Ord, Read, Show) - -_Attribute = Core.Name "hydra.csharp.syntax.Attribute" - -_Attribute_name = Core.Name "name" - -_Attribute_arguments = Core.Name "arguments" - --- | An expression usable as an attribute argument (a compile-time constant expression). -newtype AttributeArgumentExpression = - AttributeArgumentExpression { - unAttributeArgumentExpression :: NonAssignmentExpression} - deriving (Eq, Ord, Read, Show) - -_AttributeArgumentExpression = Core.Name "hydra.csharp.syntax.AttributeArgumentExpression" - --- | The positional and named argument lists supplied to an attribute. -data AttributeArguments = - AttributeArguments { - attributeArgumentsPositonal :: (Maybe PositionalArgumentList), - attributeArgumentsNamed :: (Maybe NamedArgumentList)} - deriving (Eq, Ord, Read, Show) - -_AttributeArguments = Core.Name "hydra.csharp.syntax.AttributeArguments" - -_AttributeArguments_positonal = Core.Name "positonal" - -_AttributeArguments_named = Core.Name "named" - --- | A non-empty, comma-separated list of attributes within a single attribute section. -newtype AttributeList = - AttributeList { - unAttributeList :: [Attribute]} - deriving (Eq, Ord, Read, Show) - -_AttributeList = Core.Name "hydra.csharp.syntax.AttributeList" - --- | The type name referenced by an attribute, resolved against types ending in the suffix Attribute. -newtype AttributeName = - AttributeName { - unAttributeName :: TypeName} - deriving (Eq, Ord, Read, Show) - -_AttributeName = Core.Name "hydra.csharp.syntax.AttributeName" - --- | A bracketed attribute section, with an optional target specifier, attached to a declaration. -data AttributeSection = - AttributeSection { - attributeSectionTarget :: (Maybe AttributeTarget), - attributeSectionAttributes :: AttributeList} - deriving (Eq, Ord, Read, Show) - -_AttributeSection = Core.Name "hydra.csharp.syntax.AttributeSection" - -_AttributeSection_target = Core.Name "target" - -_AttributeSection_attributes = Core.Name "attributes" - --- | The target specifier of an attribute section (e.g. assembly, module, return, field). -data AttributeTarget = - AttributeTargetIdentifier Identifier | - AttributeTargetKeyword Keyword - deriving (Eq, Ord, Read, Show) - -_AttributeTarget = Core.Name "hydra.csharp.syntax.AttributeTarget" - -_AttributeTarget_identifier = Core.Name "identifier" - -_AttributeTarget_keyword = Core.Name "keyword" - --- | A non-empty sequence of attribute sections attached to a single declaration. -newtype Attributes = - Attributes { - unAttributes :: [AttributeSection]} - deriving (Eq, Ord, Read, Show) - -_Attributes = Core.Name "hydra.csharp.syntax.Attributes" - --- | A 'base' access expression, either invoking a base member or indexing via base[args]. -data BaseAccess = - BaseAccessIdentifier BaseAccessWithIdentifier | - BaseAccessArguments ArgumentList - deriving (Eq, Ord, Read, Show) - -_BaseAccess = Core.Name "hydra.csharp.syntax.BaseAccess" - -_BaseAccess_identifier = Core.Name "identifier" - -_BaseAccess_arguments = Core.Name "arguments" - --- | A 'base.member' access, with an optional list of type arguments. -data BaseAccessWithIdentifier = - BaseAccessWithIdentifier { - baseAccessWithIdentifierIdentifier :: Identifier, - baseAccessWithIdentifierTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_BaseAccessWithIdentifier = Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier" - -_BaseAccessWithIdentifier_identifier = Core.Name "identifier" - -_BaseAccessWithIdentifier_typeArguments = Core.Name "typeArguments" - --- | A binary addition or subtraction expression with a left operand, operator, and right operand. -data BinaryAdditiveExpression = - BinaryAdditiveExpression { - binaryAdditiveExpressionLeft :: AdditiveExpression, - binaryAdditiveExpressionOperator :: AdditiveOperator, - binaryAdditiveExpressionRight :: MultiplicativeExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryAdditiveExpression = Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression" - -_BinaryAdditiveExpression_left = Core.Name "left" - -_BinaryAdditiveExpression_operator = Core.Name "operator" - -_BinaryAdditiveExpression_right = Core.Name "right" - --- | A binary bitwise-AND expression (&) over two operand expressions. -data BinaryAndExpression = - BinaryAndExpression { - binaryAndExpressionLeft :: AndExpression, - binaryAndExpressionRight :: EqualityExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryAndExpression = Core.Name "hydra.csharp.syntax.BinaryAndExpression" - -_BinaryAndExpression_left = Core.Name "left" - -_BinaryAndExpression_right = Core.Name "right" - --- | A binary conditional-AND expression (&&) over two operand expressions. -data BinaryConditionalAndExpression = - BinaryConditionalAndExpression { - binaryConditionalAndExpressionLeft :: ConditionalAndExpression, - binaryConditionalAndExpressionRight :: InclusiveOrExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryConditionalAndExpression = Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression" - -_BinaryConditionalAndExpression_left = Core.Name "left" - -_BinaryConditionalAndExpression_right = Core.Name "right" - --- | A binary conditional-OR expression (||) over two operand expressions. -data BinaryConditionalOrExpression = - BinaryConditionalOrExpression { - binaryConditionalOrExpressionLeft :: ConditionalOrExpression, - binaryConditionalOrExpressionRight :: ConditionalAndExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryConditionalOrExpression = Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression" - -_BinaryConditionalOrExpression_left = Core.Name "left" - -_BinaryConditionalOrExpression_right = Core.Name "right" - --- | A binary equality or inequality comparison expression. -data BinaryEqualityExpression = - BinaryEqualityExpression { - binaryEqualityExpressionLeft :: EqualityExpression, - binaryEqualityExpressionOperator :: EqualityOperator, - binaryEqualityExpressionRight :: RelationalExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryEqualityExpression = Core.Name "hydra.csharp.syntax.BinaryEqualityExpression" - -_BinaryEqualityExpression_left = Core.Name "left" - -_BinaryEqualityExpression_operator = Core.Name "operator" - -_BinaryEqualityExpression_right = Core.Name "right" - --- | A binary bitwise exclusive-OR expression (^) over two operand expressions. -data BinaryExclusiveOrExpression = - BinaryExclusiveOrExpression { - binaryExclusiveOrExpressionLeft :: ExclusiveOrExpression, - binaryExclusiveOrExpressionRight :: AndExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryExclusiveOrExpression = Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression" - -_BinaryExclusiveOrExpression_left = Core.Name "left" - -_BinaryExclusiveOrExpression_right = Core.Name "right" - --- | A binary bitwise inclusive-OR expression (|) over two operand expressions. -data BinaryInclusiveOrExpression = - BinaryInclusiveOrExpression { - binaryInclusiveOrExpressionLeft :: InclusiveOrExpression, - binaryInclusiveOrExpressionRight :: ExclusiveOrExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryInclusiveOrExpression = Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression" - -_BinaryInclusiveOrExpression_left = Core.Name "left" - -_BinaryInclusiveOrExpression_right = Core.Name "right" - --- | A binary multiplication, division, or remainder expression. -data BinaryMultiplicativeExpression = - BinaryMultiplicativeExpression { - binaryMultiplicativeExpressionLeft :: MultiplicativeExpression, - binaryMultiplicativeExpressionOperator :: MultiplicativeOperator, - binaryMultiplicativeExpressionRight :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryMultiplicativeExpression = Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression" - -_BinaryMultiplicativeExpression_left = Core.Name "left" - -_BinaryMultiplicativeExpression_operator = Core.Name "operator" - -_BinaryMultiplicativeExpression_right = Core.Name "right" - --- | A binary null-coalescing expression (??) over two operand expressions. -data BinaryNullCoalescingExpression = - BinaryNullCoalescingExpression { - binaryNullCoalescingExpressionLeft :: ConditionalOrExpression, - binaryNullCoalescingExpressionRight :: NullCoalescingExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryNullCoalescingExpression = Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression" - -_BinaryNullCoalescingExpression_left = Core.Name "left" - -_BinaryNullCoalescingExpression_right = Core.Name "right" - --- | The declarator for a user-defined binary operator overload, naming its two parameters. -data BinaryOperatorDeclarator = - BinaryOperatorDeclarator { - binaryOperatorDeclaratorType :: Type, - binaryOperatorDeclaratorOperator :: OverloadableBinaryOperator, - binaryOperatorDeclaratorLeft :: FixedParameter, - binaryOperatorDeclaratorRight :: FixedParameter} - deriving (Eq, Ord, Read, Show) - -_BinaryOperatorDeclarator = Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator" - -_BinaryOperatorDeclarator_type = Core.Name "type" - -_BinaryOperatorDeclarator_operator = Core.Name "operator" - -_BinaryOperatorDeclarator_left = Core.Name "left" - -_BinaryOperatorDeclarator_right = Core.Name "right" - --- | A binary relational comparison expression (<, >, <=, or >=). -data BinaryRelationalExpression = - BinaryRelationalExpression { - binaryRelationalExpressionLeft :: RelationalExpression, - binaryRelationalExpressionOperator :: RelationalOperator, - binaryRelationalExpressionRight :: ShiftExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryRelationalExpression = Core.Name "hydra.csharp.syntax.BinaryRelationalExpression" - -_BinaryRelationalExpression_left = Core.Name "left" - -_BinaryRelationalExpression_operator = Core.Name "operator" - -_BinaryRelationalExpression_right = Core.Name "right" - --- | A binary left-shift or right-shift expression. -data BinaryShiftExpression = - BinaryShiftExpression { - binaryShiftExpressionLeft :: ShiftExpression, - binaryShiftExpressionOperator :: ShiftOperator, - binaryShiftExpressionRight :: AdditiveExpression} - deriving (Eq, Ord, Read, Show) - -_BinaryShiftExpression = Core.Name "hydra.csharp.syntax.BinaryShiftExpression" - -_BinaryShiftExpression_left = Core.Name "left" - -_BinaryShiftExpression_operator = Core.Name "operator" - -_BinaryShiftExpression_right = Core.Name "right" - --- | A brace-delimited sequence of statements forming a single compound statement. -newtype Block = - Block { - unBlock :: [Statement]} - deriving (Eq, Ord, Read, Show) - -_Block = Core.Name "hydra.csharp.syntax.Block" - --- | A property body given as get/set accessor declarations, with an optional initializer. -data BlockPropertyBody = - BlockPropertyBody { - blockPropertyBodyAccessors :: AccessorDeclarations, - blockPropertyBodyInitializer :: (Maybe VariableInitializer)} - deriving (Eq, Ord, Read, Show) - -_BlockPropertyBody = Core.Name "hydra.csharp.syntax.BlockPropertyBody" - -_BlockPropertyBody_accessors = Core.Name "accessors" - -_BlockPropertyBody_initializer = Core.Name "initializer" - --- | An expression required to have (or be convertible to) type bool, such as an if condition. -newtype BooleanExpression = - BooleanExpression { - unBooleanExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_BooleanExpression = Core.Name "hydra.csharp.syntax.BooleanExpression" - --- | An explicit type-cast expression applied to a unary expression. -data CastExpression = - CastExpression { - castExpressionType :: Type, - castExpressionExpression :: UnaryExpression} - deriving (Eq, Ord, Read, Show) - -_CastExpression = Core.Name "hydra.csharp.syntax.CastExpression" - -_CastExpression_type = Core.Name "type" - -_CastExpression_expression = Core.Name "expression" - --- | The catch clauses of a try statement: one or more specific clauses, or a single general clause. -data CatchClauses = - CatchClausesSpecific [SpecificCatchClause] | - CatchClausesGeneral Block - deriving (Eq, Ord, Read, Show) - -_CatchClauses = Core.Name "hydra.csharp.syntax.CatchClauses" - -_CatchClauses_specific = Core.Name "specific" - -_CatchClauses_general = Core.Name "general" - --- | The base class and/or implemented interfaces listed in a class declaration's base-list. -data ClassBase = - ClassBaseClass (Maybe ClassType) | - ClassBaseInterfaces [InterfaceType] - deriving (Eq, Ord, Read, Show) - -_ClassBase = Core.Name "hydra.csharp.syntax.ClassBase" - -_ClassBase_class = Core.Name "class" - -_ClassBase_interfaces = Core.Name "interfaces" - --- | The brace-delimited sequence of member declarations that make up a class. -newtype ClassBody = - ClassBody { - unClassBody :: [ClassMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_ClassBody = Core.Name "hydra.csharp.syntax.ClassBody" - --- | A C# class declaration, including its modifiers, type parameters, base list, and body. -data ClassDeclaration = - ClassDeclaration { - classDeclarationAttributes :: [AttributeSection], - classDeclarationModifiers :: [ClassModifier], - classDeclarationPartial :: Bool, - classDeclarationName :: Identifier, - classDeclarationParameters :: (Maybe TypeParameterList), - classDeclarationBase :: (Maybe ClassBase), - classDeclarationConstraints :: [TypeParameterConstraintsClause], - classDeclarationBody :: ClassBody} - deriving (Eq, Ord, Read, Show) - -_ClassDeclaration = Core.Name "hydra.csharp.syntax.ClassDeclaration" - -_ClassDeclaration_attributes = Core.Name "attributes" - -_ClassDeclaration_modifiers = Core.Name "modifiers" - -_ClassDeclaration_partial = Core.Name "partial" - -_ClassDeclaration_name = Core.Name "name" - -_ClassDeclaration_parameters = Core.Name "parameters" - -_ClassDeclaration_base = Core.Name "base" - -_ClassDeclaration_constraints = Core.Name "constraints" - -_ClassDeclaration_body = Core.Name "body" - --- | Any member that can appear in a class body: field, method, property, event, and so on. -data ClassMemberDeclaration = - ClassMemberDeclarationConstant ConstantDeclaration | - ClassMemberDeclarationField FieldDeclaration | - ClassMemberDeclarationMethod MethodDeclaration | - ClassMemberDeclarationProperty PropertyDeclaration | - ClassMemberDeclarationEvent EventDeclaration | - ClassMemberDeclarationIndexer IndexerDeclaration | - ClassMemberDeclarationOperator OperatorDeclaration | - ClassMemberDeclarationConstructor ConstructorDeclaration | - ClassMemberDeclarationFinalizer FinalizerDeclaration | - ClassMemberDeclarationStaticConstructor StaticConstructorDeclaration | - ClassMemberDeclarationType TypeDeclaration - deriving (Eq, Ord, Read, Show) - -_ClassMemberDeclaration = Core.Name "hydra.csharp.syntax.ClassMemberDeclaration" - -_ClassMemberDeclaration_constant = Core.Name "constant" - -_ClassMemberDeclaration_field = Core.Name "field" - -_ClassMemberDeclaration_method = Core.Name "method" - -_ClassMemberDeclaration_property = Core.Name "property" - -_ClassMemberDeclaration_event = Core.Name "event" - -_ClassMemberDeclaration_indexer = Core.Name "indexer" - -_ClassMemberDeclaration_operator = Core.Name "operator" - -_ClassMemberDeclaration_constructor = Core.Name "constructor" - -_ClassMemberDeclaration_finalizer = Core.Name "finalizer" - -_ClassMemberDeclaration_staticConstructor = Core.Name "staticConstructor" - -_ClassMemberDeclaration_type = Core.Name "type" - --- | A modifier keyword on a class declaration, such as public, abstract, sealed, or static. -data ClassModifier = - ClassModifierNew | - ClassModifierPublic | - ClassModifierProtected | - ClassModifierInternal | - ClassModifierPrivate | - ClassModifierAbstract | - ClassModifierSealed | - ClassModifierStatic | - ClassModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_ClassModifier = Core.Name "hydra.csharp.syntax.ClassModifier" - -_ClassModifier_new = Core.Name "new" - -_ClassModifier_public = Core.Name "public" - -_ClassModifier_protected = Core.Name "protected" - -_ClassModifier_internal = Core.Name "internal" - -_ClassModifier_private = Core.Name "private" - -_ClassModifier_abstract = Core.Name "abstract" - -_ClassModifier_sealed = Core.Name "sealed" - -_ClassModifier_static = Core.Name "static" - -_ClassModifier_unsafe = Core.Name "unsafe" - --- | A reference to a class type: a named type, or the predefined 'object' or 'string' types. -data ClassType = - ClassTypeTypeName TypeName | - ClassTypeObject | - ClassTypeString - deriving (Eq, Ord, Read, Show) - -_ClassType = Core.Name "hydra.csharp.syntax.ClassType" - -_ClassType_typeName = Core.Name "typeName" - -_ClassType_object = Core.Name "object" - -_ClassType_string = Core.Name "string" - --- | The root of a C# source file: extern aliases, using directives, attributes, and type members. -data CompilationUnit = - CompilationUnit { - compilationUnitExterns :: [ExternAliasDirective], - compilationUnitUsings :: [UsingDirective], - compilationUnitAttributes :: [GlobalAttributeSection], - compilationUnitMembers :: [NamespaceMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_CompilationUnit = Core.Name "hydra.csharp.syntax.CompilationUnit" - -_CompilationUnit_externs = Core.Name "externs" - -_CompilationUnit_usings = Core.Name "usings" - -_CompilationUnit_attributes = Core.Name "attributes" - -_CompilationUnit_members = Core.Name "members" - --- | A simple inclusive-OR expression or a binary conditional-AND (&&) expression. -data ConditionalAndExpression = - ConditionalAndExpressionSimple InclusiveOrExpression | - ConditionalAndExpressionBinary BinaryConditionalAndExpression - deriving (Eq, Ord, Read, Show) - -_ConditionalAndExpression = Core.Name "hydra.csharp.syntax.ConditionalAndExpression" - -_ConditionalAndExpression_simple = Core.Name "simple" - -_ConditionalAndExpression_binary = Core.Name "binary" - --- | The ternary conditional expression, in its simple, ref-conditional, or fallthrough forms. -data ConditionalExpression = - ConditionalExpressionSimple NullCoalescingExpression | - ConditionalExpressionSimpleConditional SimpleConditionalExpression | - ConditionalExpressionRefConditional RefConditionalExpression - deriving (Eq, Ord, Read, Show) - -_ConditionalExpression = Core.Name "hydra.csharp.syntax.ConditionalExpression" - -_ConditionalExpression_simple = Core.Name "simple" - -_ConditionalExpression_simpleConditional = Core.Name "simpleConditional" - -_ConditionalExpression_refConditional = Core.Name "refConditional" - --- | A simple conditional-AND expression or a binary conditional-OR (||) expression. -data ConditionalOrExpression = - ConditionalOrExpressionSimple ConditionalAndExpression | - ConditionalOrExpressionBinary BinaryConditionalOrExpression - deriving (Eq, Ord, Read, Show) - -_ConditionalOrExpression = Core.Name "hydra.csharp.syntax.ConditionalOrExpression" - -_ConditionalOrExpression_simple = Core.Name "simple" - -_ConditionalOrExpression_binary = Core.Name "binary" - --- | A 'const' field declaration with its modifiers, type, and one or more declarators. -data ConstantDeclaration = - ConstantDeclaration { - constantDeclarationAttributes :: (Maybe Attributes), - constantDeclarationModifiers :: [ConstantModifier], - constantDeclarationType :: Type, - constantDeclarationDeclarators :: [ConstantDeclarator]} - deriving (Eq, Ord, Read, Show) - -_ConstantDeclaration = Core.Name "hydra.csharp.syntax.ConstantDeclaration" - -_ConstantDeclaration_attributes = Core.Name "attributes" - -_ConstantDeclaration_modifiers = Core.Name "modifiers" - -_ConstantDeclaration_type = Core.Name "type" - -_ConstantDeclaration_declarators = Core.Name "declarators" - --- | A single 'identifier = expression' pair within a constant declaration. -data ConstantDeclarator = - ConstantDeclarator { - constantDeclaratorIdentifier :: Identifier, - constantDeclaratorExpression :: ConstantExpression} - deriving (Eq, Ord, Read, Show) - -_ConstantDeclarator = Core.Name "hydra.csharp.syntax.ConstantDeclarator" - -_ConstantDeclarator_identifier = Core.Name "identifier" - -_ConstantDeclarator_expression = Core.Name "expression" - --- | An expression that is required to be evaluable at compile time. -newtype ConstantExpression = - ConstantExpression { - unConstantExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_ConstantExpression = Core.Name "hydra.csharp.syntax.ConstantExpression" - --- | An access modifier (new, public, protected, internal, or private) on a constant declaration. -data ConstantModifier = - ConstantModifierNew | - ConstantModifierPublic | - ConstantModifierProtected | - ConstantModifierInternal | - ConstantModifierPrivate - deriving (Eq, Ord, Read, Show) - -_ConstantModifier = Core.Name "hydra.csharp.syntax.ConstantModifier" - -_ConstantModifier_new = Core.Name "new" - -_ConstantModifier_public = Core.Name "public" - -_ConstantModifier_protected = Core.Name "protected" - -_ConstantModifier_internal = Core.Name "internal" - -_ConstantModifier_private = Core.Name "private" - --- | The body of an instance constructor: a block, expression body, or empty (extern) body. -data ConstructorBody = - ConstructorBodyBlock Block | - ConstructorBodyExpression Expression | - ConstructorBodyEmpty - deriving (Eq, Ord, Read, Show) - -_ConstructorBody = Core.Name "hydra.csharp.syntax.ConstructorBody" - -_ConstructorBody_block = Core.Name "block" - -_ConstructorBody_expression = Core.Name "expression" - -_ConstructorBody_empty = Core.Name "empty" - --- | An instance constructor declaration, including its declarator and body. -data ConstructorDeclaration = - ConstructorDeclaration { - constructorDeclarationAttributes :: (Maybe Attributes), - constructorDeclarationModifiers :: [ConstructorModifier], - constructorDeclarationDeclarator :: ConstructorDeclarator, - constructorDeclarationBody :: ConstructorBody} - deriving (Eq, Ord, Read, Show) - -_ConstructorDeclaration = Core.Name "hydra.csharp.syntax.ConstructorDeclaration" - -_ConstructorDeclaration_attributes = Core.Name "attributes" - -_ConstructorDeclaration_modifiers = Core.Name "modifiers" - -_ConstructorDeclaration_declarator = Core.Name "declarator" - -_ConstructorDeclaration_body = Core.Name "body" - --- | A constructor's name, parameter list, and optional base/this initializer. -data ConstructorDeclarator = - ConstructorDeclarator { - constructorDeclaratorName :: Identifier, - constructorDeclaratorParameters :: (Maybe FormalParameterList), - constructorDeclaratorInitializer :: (Maybe ConstructorInitializer)} - deriving (Eq, Ord, Read, Show) - -_ConstructorDeclarator = Core.Name "hydra.csharp.syntax.ConstructorDeclarator" - -_ConstructorDeclarator_name = Core.Name "name" - -_ConstructorDeclarator_parameters = Core.Name "parameters" - -_ConstructorDeclarator_initializer = Core.Name "initializer" - --- | A ': base(...)' or ': this(...)' initializer invoked before a constructor body runs. -data ConstructorInitializer = - ConstructorInitializerBase (Maybe ArgumentList) | - ConstructorInitializerThis (Maybe ArgumentList) - deriving (Eq, Ord, Read, Show) - -_ConstructorInitializer = Core.Name "hydra.csharp.syntax.ConstructorInitializer" - -_ConstructorInitializer_base = Core.Name "base" - -_ConstructorInitializer_this = Core.Name "this" - --- | An access or extern/unsafe modifier on an instance constructor declaration. -data ConstructorModifier = - ConstructorModifierPublic | - ConstructorModifierProtected | - ConstructorModifierInternal | - ConstructorModifierPrivate | - ConstructorModifierExtern | - ConstructorModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_ConstructorModifier = Core.Name "hydra.csharp.syntax.ConstructorModifier" - -_ConstructorModifier_public = Core.Name "public" - -_ConstructorModifier_protected = Core.Name "protected" - -_ConstructorModifier_internal = Core.Name "internal" - -_ConstructorModifier_private = Core.Name "private" - -_ConstructorModifier_extern = Core.Name "extern" - -_ConstructorModifier_unsafe = Core.Name "unsafe" - --- | Whether a user-defined conversion operator is implicit or explicit. -data ConversionKind = - ConversionKindImplicit | - ConversionKindExplicit - deriving (Eq, Ord, Read, Show) - -_ConversionKind = Core.Name "hydra.csharp.syntax.ConversionKind" - -_ConversionKind_implicit = Core.Name "implicit" - -_ConversionKind_explicit = Core.Name "explicit" - --- | The declarator for a user-defined implicit or explicit conversion operator. -data ConversionOperatorDeclarator = - ConversionOperatorDeclarator { - conversionOperatorDeclaratorKind :: ConversionKind, - conversionOperatorDeclaratorType :: Type, - conversionOperatorDeclaratorParameter :: FixedParameter} - deriving (Eq, Ord, Read, Show) - -_ConversionOperatorDeclarator = Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator" - -_ConversionOperatorDeclarator_kind = Core.Name "kind" - -_ConversionOperatorDeclarator_type = Core.Name "type" - -_ConversionOperatorDeclarator_parameter = Core.Name "parameter" - --- | An inline variable declaration used as an expression, such as an out-variable declaration. -data DeclarationExpression = - DeclarationExpression { - declarationExpressionType :: LocalVariableType, - declarationExpressionIdentifier :: Identifier} - deriving (Eq, Ord, Read, Show) - -_DeclarationExpression = Core.Name "hydra.csharp.syntax.DeclarationExpression" - -_DeclarationExpression_type = Core.Name "type" - -_DeclarationExpression_identifier = Core.Name "identifier" - --- | A pattern that tests an expression's type and, on success, binds it to a designation. -data DeclarationPattern = - DeclarationPattern { - declarationPatternType :: Type, - declarationPatternDesignation :: Designation} - deriving (Eq, Ord, Read, Show) - -_DeclarationPattern = Core.Name "hydra.csharp.syntax.DeclarationPattern" - -_DeclarationPattern_type = Core.Name "type" - -_DeclarationPattern_designation = Core.Name "designation" - --- | A local variable, local constant, or local function declaration statement. -data DeclarationStatement = - DeclarationStatementVariable LocalVariableDeclaration | - DeclarationStatementConstant LocalConstantDeclaration | - DeclarationStatementFunction LocalFunctionDeclaration - deriving (Eq, Ord, Read, Show) - -_DeclarationStatement = Core.Name "hydra.csharp.syntax.DeclarationStatement" - -_DeclarationStatement_variable = Core.Name "variable" - -_DeclarationStatement_constant = Core.Name "constant" - -_DeclarationStatement_function = Core.Name "function" - --- | One element of a deconstruction pattern: a nested tuple or a bound identifier. -data DeconstructionElement = - DeconstructionElementTuple DeconstructionTuple | - DeconstructionElementIdentifier Identifier - deriving (Eq, Ord, Read, Show) - -_DeconstructionElement = Core.Name "hydra.csharp.syntax.DeconstructionElement" - -_DeconstructionElement_tuple = Core.Name "tuple" - -_DeconstructionElement_identifier = Core.Name "identifier" - --- | A tuple deconstruction pattern used on the left-hand side of a deconstructing assignment. -newtype DeconstructionTuple = - DeconstructionTuple { - unDeconstructionTuple :: [DeconstructionElement]} - deriving (Eq, Ord, Read, Show) - -_DeconstructionTuple = Core.Name "hydra.csharp.syntax.DeconstructionTuple" - --- | A 'default(T)' expression, or the type-inferred 'default' literal. -data DefaultValueExpression = - DefaultValueExpressionExplicitlyTyped Type | - DefaultValueExpressionDefaultLiteral - deriving (Eq, Ord, Read, Show) - -_DefaultValueExpression = Core.Name "hydra.csharp.syntax.DefaultValueExpression" - -_DefaultValueExpression_explicitlyTyped = Core.Name "explicitlyTyped" - -_DefaultValueExpression_defaultLiteral = Core.Name "defaultLiteral" - --- | An expression that creates a delegate instance from a method group or lambda. -data DelegateCreationExpression = - DelegateCreationExpression { - delegateCreationExpressionType :: DelegateType, - delegateCreationExpressionExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_DelegateCreationExpression = Core.Name "hydra.csharp.syntax.DelegateCreationExpression" - -_DelegateCreationExpression_type = Core.Name "type" - -_DelegateCreationExpression_expression = Core.Name "expression" - --- | A delegate type declaration, naming its return type, ref kind, and parameter list. -data DelegateDeclaration = - DelegateDeclaration { - delegateDeclarationAttributes :: (Maybe Attributes), - delegateDeclarationModifiers :: [DelegateModifier], - delegateDeclarationReturnType :: ReturnType, - delegateDeclarationRefKind :: (Maybe RefKind), - delegateDeclarationRefReturnType :: (Maybe Type), - delegateDeclarationHeader :: DelegateHeader} - deriving (Eq, Ord, Read, Show) - -_DelegateDeclaration = Core.Name "hydra.csharp.syntax.DelegateDeclaration" - -_DelegateDeclaration_attributes = Core.Name "attributes" - -_DelegateDeclaration_modifiers = Core.Name "modifiers" - -_DelegateDeclaration_returnType = Core.Name "returnType" - -_DelegateDeclaration_refKind = Core.Name "refKind" - -_DelegateDeclaration_refReturnType = Core.Name "refReturnType" - -_DelegateDeclaration_header = Core.Name "header" - --- | The name, type parameters, formal parameters, and constraints of a delegate declaration. -data DelegateHeader = - DelegateHeader { - delegateHeaderName :: Identifier, - delegateHeaderTypeParameters :: (Maybe VariantTypeParameters), - delegateHeaderParameters :: (Maybe FormalParameterList), - delegateHeaderConstraints :: [TypeParameterConstraintsClause]} - deriving (Eq, Ord, Read, Show) - -_DelegateHeader = Core.Name "hydra.csharp.syntax.DelegateHeader" - -_DelegateHeader_name = Core.Name "name" - -_DelegateHeader_typeParameters = Core.Name "typeParameters" - -_DelegateHeader_parameters = Core.Name "parameters" - -_DelegateHeader_constraints = Core.Name "constraints" - --- | An access or unsafe modifier on a delegate type declaration. -data DelegateModifier = - DelegateModifierNew | - DelegateModifierPublic | - DelegateModifierProtected | - DelegateModifierInternal | - DelegateModifierPrivate | - DelegateModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_DelegateModifier = Core.Name "hydra.csharp.syntax.DelegateModifier" - -_DelegateModifier_new = Core.Name "new" - -_DelegateModifier_public = Core.Name "public" - -_DelegateModifier_protected = Core.Name "protected" - -_DelegateModifier_internal = Core.Name "internal" - -_DelegateModifier_private = Core.Name "private" - -_DelegateModifier_unsafe = Core.Name "unsafe" - --- | A reference to a delegate type by its type name. -newtype DelegateType = - DelegateType { - unDelegateType :: TypeName} - deriving (Eq, Ord, Read, Show) - -_DelegateType = Core.Name "hydra.csharp.syntax.DelegateType" - --- | A member access, element access, or invocation chained after a null-conditional operator. -data DependentAccess = - DependentAccessMemberAccess DependentAccessForMember | - DependentAccessElementAccess ArgumentList | - DependentAccessInvocation (Maybe ArgumentList) - deriving (Eq, Ord, Read, Show) - -_DependentAccess = Core.Name "hydra.csharp.syntax.DependentAccess" - -_DependentAccess_memberAccess = Core.Name "memberAccess" - -_DependentAccess_elementAccess = Core.Name "elementAccess" - -_DependentAccess_invocation = Core.Name "invocation" - --- | A member identifier and optional type arguments chained after a null-conditional access. -data DependentAccessForMember = - DependentAccessForMember { - dependentAccessForMemberIdentifier :: Identifier, - dependentAccessForMemberTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_DependentAccessForMember = Core.Name "hydra.csharp.syntax.DependentAccessForMember" - -_DependentAccessForMember_identifier = Core.Name "identifier" - -_DependentAccessForMember_typeArguments = Core.Name "typeArguments" - --- | A simple identifier binding introduced by a pattern, such as in a declaration pattern. -newtype Designation = - Designation { - unDesignation :: Identifier} - deriving (Eq, Ord, Read, Show) - -_Designation = Core.Name "hydra.csharp.syntax.Designation" - --- | A do-while iteration statement that executes its body at least once. -data DoStatement = - DoStatement { - doStatementBody :: EmbeddedStatement, - doStatementWhile :: BooleanExpression} - deriving (Eq, Ord, Read, Show) - -_DoStatement = Core.Name "hydra.csharp.syntax.DoStatement" - -_DoStatement_body = Core.Name "body" - -_DoStatement_while = Core.Name "while" - --- | An indexer access expression applying an argument list to a primary expression. -data ElementAccess = - ElementAccess { - elementAccessExpression :: PrimaryNoArrayCreationExpression, - elementAccessArguments :: ArgumentList} - deriving (Eq, Ord, Read, Show) - -_ElementAccess = Core.Name "hydra.csharp.syntax.ElementAccess" - -_ElementAccess_expression = Core.Name "expression" - -_ElementAccess_arguments = Core.Name "arguments" - --- | A single element of a collection initializer: one expression, or a nested element list. -data ElementInitializer = - ElementInitializerSingle NonAssignmentExpression | - ElementInitializerList ExpressionList - deriving (Eq, Ord, Read, Show) - -_ElementInitializer = Core.Name "hydra.csharp.syntax.ElementInitializer" - -_ElementInitializer_single = Core.Name "single" - -_ElementInitializer_list = Core.Name "list" - --- | A statement nested inside another statement, excluding labeled and declaration statements. -data EmbeddedStatement = - EmbeddedStatementBlock Block | - EmbeddedStatementEmpty | - EmbeddedStatementExpression StatementExpression | - EmbeddedStatementSelection SelectionStatement | - EmbeddedStatementIteration IterationStatement | - EmbeddedStatementJump JumpStatement | - EmbeddedStatementTry TryStatement | - EmbeddedStatementChecked Block | - EmbeddedStatementUnchecked Block | - EmbeddedStatementLock LockStatement | - EmbeddedStatementUsing UsingStatement | - EmbeddedStatementYield YieldStatement | - EmbeddedStatementUnsafe Block | - EmbeddedStatementFixed FixedStatement - deriving (Eq, Ord, Read, Show) - -_EmbeddedStatement = Core.Name "hydra.csharp.syntax.EmbeddedStatement" - -_EmbeddedStatement_block = Core.Name "block" - -_EmbeddedStatement_empty = Core.Name "empty" - -_EmbeddedStatement_expression = Core.Name "expression" - -_EmbeddedStatement_selection = Core.Name "selection" - -_EmbeddedStatement_iteration = Core.Name "iteration" - -_EmbeddedStatement_jump = Core.Name "jump" - -_EmbeddedStatement_try = Core.Name "try" - -_EmbeddedStatement_checked = Core.Name "checked" - -_EmbeddedStatement_unchecked = Core.Name "unchecked" - -_EmbeddedStatement_lock = Core.Name "lock" - -_EmbeddedStatement_using = Core.Name "using" - -_EmbeddedStatement_yield = Core.Name "yield" - -_EmbeddedStatement_unsafe = Core.Name "unsafe" - -_EmbeddedStatement_fixed = Core.Name "fixed" - --- | The optional explicit underlying integral type declared for an enum. -data EnumBase = - EnumBaseType IntegralType | - EnumBaseName TypeName - deriving (Eq, Ord, Read, Show) - -_EnumBase = Core.Name "hydra.csharp.syntax.EnumBase" - -_EnumBase_type = Core.Name "type" - -_EnumBase_name = Core.Name "name" - --- | The brace-delimited list of member declarations that make up an enum. -newtype EnumBody = - EnumBody { - unEnumBody :: [EnumMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_EnumBody = Core.Name "hydra.csharp.syntax.EnumBody" - --- | An enum type declaration, with its modifiers, name, underlying type, and members. -data EnumDeclaration = - EnumDeclaration { - enumDeclarationAttributes :: (Maybe Attributes), - enumDeclarationModifiers :: [EnumModifier], - enumDeclarationName :: Identifier, - enumDeclarationBase :: (Maybe EnumBase), - enumDeclarationBody :: (Maybe EnumBody)} - deriving (Eq, Ord, Read, Show) - -_EnumDeclaration = Core.Name "hydra.csharp.syntax.EnumDeclaration" - -_EnumDeclaration_attributes = Core.Name "attributes" - -_EnumDeclaration_modifiers = Core.Name "modifiers" - -_EnumDeclaration_name = Core.Name "name" - -_EnumDeclaration_base = Core.Name "base" - -_EnumDeclaration_body = Core.Name "body" - --- | A single named enum member, with optional attributes and an explicit constant value. -data EnumMemberDeclaration = - EnumMemberDeclaration { - enumMemberDeclarationAttributes :: (Maybe Attributes), - enumMemberDeclarationName :: Identifier, - enumMemberDeclarationValue :: (Maybe ConstantExpression)} - deriving (Eq, Ord, Read, Show) - -_EnumMemberDeclaration = Core.Name "hydra.csharp.syntax.EnumMemberDeclaration" - -_EnumMemberDeclaration_attributes = Core.Name "attributes" - -_EnumMemberDeclaration_name = Core.Name "name" - -_EnumMemberDeclaration_value = Core.Name "value" - --- | An access modifier (new, public, protected, internal, or private) on an enum declaration. -data EnumModifier = - EnumModifierNew | - EnumModifierPublic | - EnumModifierProtected | - EnumModifierInternal | - EnumModifierPrivate - deriving (Eq, Ord, Read, Show) - -_EnumModifier = Core.Name "hydra.csharp.syntax.EnumModifier" - -_EnumModifier_new = Core.Name "new" - -_EnumModifier_public = Core.Name "public" - -_EnumModifier_protected = Core.Name "protected" - -_EnumModifier_internal = Core.Name "internal" - -_EnumModifier_private = Core.Name "private" - --- | A reference to an enum type by its type name. -newtype EnumType = - EnumType { - unEnumType :: TypeName} - deriving (Eq, Ord, Read, Show) - -_EnumType = Core.Name "hydra.csharp.syntax.EnumType" - --- | A simple relational expression or a binary equality/inequality expression. -data EqualityExpression = - EqualityExpressionSimple RelationalExpression | - EqualityExpressionBinary BinaryEqualityExpression - deriving (Eq, Ord, Read, Show) - -_EqualityExpression = Core.Name "hydra.csharp.syntax.EqualityExpression" - -_EqualityExpression_simple = Core.Name "simple" - -_EqualityExpression_binary = Core.Name "binary" - --- | The equality (==) or inequality (!=) operator. -data EqualityOperator = - EqualityOperatorEqual | - EqualityOperatorNotEqual - deriving (Eq, Ord, Read, Show) - -_EqualityOperator = Core.Name "hydra.csharp.syntax.EqualityOperator" - -_EqualityOperator_equal = Core.Name "equal" - -_EqualityOperator_notEqual = Core.Name "notEqual" - --- | The add and remove accessor declarations of an event with an explicit accessor body. -data EventAccessorDeclarations = - EventAccessorDeclarationsAdd AddRemoveAccessorDeclaration | - EventAccessorDeclarationsRemove AddRemoveAccessorDeclaration - deriving (Eq, Ord, Read, Show) - -_EventAccessorDeclarations = Core.Name "hydra.csharp.syntax.EventAccessorDeclarations" - -_EventAccessorDeclarations_add = Core.Name "add" - -_EventAccessorDeclarations_remove = Core.Name "remove" - --- | An event member declaration, in either its field-like or explicit-accessor form. -data EventDeclaration = - EventDeclarationStandard StandardEventDeclaration | - EventDeclarationAccessors AccessorsEventDeclaration - deriving (Eq, Ord, Read, Show) - -_EventDeclaration = Core.Name "hydra.csharp.syntax.EventDeclaration" - -_EventDeclaration_standard = Core.Name "standard" - -_EventDeclaration_accessors = Core.Name "accessors" - --- | A modifier keyword on an event declaration, such as static, virtual, or override. -data EventModifier = - EventModifierNew | - EventModifierPublic | - EventModifierProtected | - EventModifierInternal | - EventModifierPrivate | - EventModifierStatic | - EventModifierVirtual | - EventModifierSealed | - EventModifierOverride | - EventModifierAbstract | - EventModifierExtern | - EventModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_EventModifier = Core.Name "hydra.csharp.syntax.EventModifier" - -_EventModifier_new = Core.Name "new" - -_EventModifier_public = Core.Name "public" - -_EventModifier_protected = Core.Name "protected" - -_EventModifier_internal = Core.Name "internal" - -_EventModifier_private = Core.Name "private" - -_EventModifier_static = Core.Name "static" - -_EventModifier_virtual = Core.Name "virtual" - -_EventModifier_sealed = Core.Name "sealed" - -_EventModifier_override = Core.Name "override" - -_EventModifier_abstract = Core.Name "abstract" - -_EventModifier_extern = Core.Name "extern" - -_EventModifier_unsafe = Core.Name "unsafe" - --- | The exception type and optional identifier caught by a specific catch clause. -data ExceptionSpecifier = - ExceptionSpecifier { - exceptionSpecifierType :: Type, - exceptionSpecifierIdentifier :: (Maybe Identifier)} - deriving (Eq, Ord, Read, Show) - -_ExceptionSpecifier = Core.Name "hydra.csharp.syntax.ExceptionSpecifier" - -_ExceptionSpecifier_type = Core.Name "type" - -_ExceptionSpecifier_identifier = Core.Name "identifier" - --- | A simple AND expression or a binary bitwise exclusive-OR (^) expression. -data ExclusiveOrExpression = - ExclusiveOrExpressionSimple AndExpression | - ExclusiveOrExpressionBinary BinaryExclusiveOrExpression - deriving (Eq, Ord, Read, Show) - -_ExclusiveOrExpression = Core.Name "hydra.csharp.syntax.ExclusiveOrExpression" - -_ExclusiveOrExpression_simple = Core.Name "simple" - -_ExclusiveOrExpression_binary = Core.Name "binary" - --- | An explicitly typed parameter of an anonymous function, with an optional modifier. -data ExplicitAnonymousFunctionParameter = - ExplicitAnonymousFunctionParameter { - explicitAnonymousFunctionParameterModifier :: (Maybe AnonymousFunctionParameterModifier), - explicitAnonymousFunctionParameterType :: Type, - explicitAnonymousFunctionParameterIdentifier :: Identifier} - deriving (Eq, Ord, Read, Show) - -_ExplicitAnonymousFunctionParameter = Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter" - -_ExplicitAnonymousFunctionParameter_modifier = Core.Name "modifier" - -_ExplicitAnonymousFunctionParameter_type = Core.Name "type" - -_ExplicitAnonymousFunctionParameter_identifier = Core.Name "identifier" - --- | A local variable declaration whose type is written out explicitly. -data ExplicitlyTypedLocalVariableDeclaration = - ExplicitlyTypedLocalVariableDeclaration { - explicitlyTypedLocalVariableDeclarationType :: Type, - explicitlyTypedLocalVariableDeclarationDeclarators :: [ExplicitlyTypedLocalVariableDeclarator]} - deriving (Eq, Ord, Read, Show) - -_ExplicitlyTypedLocalVariableDeclaration = Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration" - -_ExplicitlyTypedLocalVariableDeclaration_type = Core.Name "type" - -_ExplicitlyTypedLocalVariableDeclaration_declarators = Core.Name "declarators" - --- | An identifier and optional initializer within an explicitly typed local declaration. -data ExplicitlyTypedLocalVariableDeclarator = - ExplicitlyTypedLocalVariableDeclarator { - explicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier, - explicitlyTypedLocalVariableDeclaratorInitializer :: (Maybe LocalVariableInitializer)} - deriving (Eq, Ord, Read, Show) - -_ExplicitlyTypedLocalVariableDeclarator = Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator" - -_ExplicitlyTypedLocalVariableDeclarator_identifier = Core.Name "identifier" - -_ExplicitlyTypedLocalVariableDeclarator_initializer = Core.Name "initializer" - --- | A non-assignment expression or an assignment expression. -data Expression = - ExpressionNonAssignment NonAssignmentExpression | - ExpressionAssignment Assignment - deriving (Eq, Ord, Read, Show) - -_Expression = Core.Name "hydra.csharp.syntax.Expression" - -_Expression_nonAssignment = Core.Name "nonAssignment" - -_Expression_assignment = Core.Name "assignment" - --- | A non-empty, comma-separated list of expressions, as used in an array creation expression. -newtype ExpressionList = - ExpressionList { - unExpressionList :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_ExpressionList = Core.Name "hydra.csharp.syntax.ExpressionList" - --- | An 'extern alias' directive introducing an alias for an external assembly reference. -newtype ExternAliasDirective = - ExternAliasDirective { - unExternAliasDirective :: Identifier} - deriving (Eq, Ord, Read, Show) - -_ExternAliasDirective = Core.Name "hydra.csharp.syntax.ExternAliasDirective" - --- | A field member declaration, with its modifiers, type, and one or more variable declarators. -data FieldDeclaration = - FieldDeclaration { - fieldDeclarationAttributes :: (Maybe Attributes), - fieldDeclarationModifiers :: [FieldModifier], - fieldDeclarationType :: Type, - fieldDeclarationDeclarators :: [VariableDeclarator]} - deriving (Eq, Ord, Read, Show) - -_FieldDeclaration = Core.Name "hydra.csharp.syntax.FieldDeclaration" - -_FieldDeclaration_attributes = Core.Name "attributes" - -_FieldDeclaration_modifiers = Core.Name "modifiers" - -_FieldDeclaration_type = Core.Name "type" - -_FieldDeclaration_declarators = Core.Name "declarators" - --- | A modifier keyword on a field declaration, such as static, readonly, or volatile. -data FieldModifier = - FieldModifierNew | - FieldModifierPublic | - FieldModifierProtected | - FieldModifierInternal | - FieldModifierPrivate | - FieldModifierStatic | - FieldModifierReadonly | - FieldModifierVolatile | - FieldModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_FieldModifier = Core.Name "hydra.csharp.syntax.FieldModifier" - -_FieldModifier_new = Core.Name "new" - -_FieldModifier_public = Core.Name "public" - -_FieldModifier_protected = Core.Name "protected" - -_FieldModifier_internal = Core.Name "internal" - -_FieldModifier_private = Core.Name "private" - -_FieldModifier_static = Core.Name "static" - -_FieldModifier_readonly = Core.Name "readonly" - -_FieldModifier_volatile = Core.Name "volatile" - -_FieldModifier_unsafe = Core.Name "unsafe" - --- | The body of a finalizer: a block, expression body, or empty (extern) body. -data FinalizerBody = - FinalizerBodyBlock Block | - FinalizerBodyExpression Expression | - FinalizerBodyEmpty - deriving (Eq, Ord, Read, Show) - -_FinalizerBody = Core.Name "hydra.csharp.syntax.FinalizerBody" - -_FinalizerBody_block = Core.Name "block" - -_FinalizerBody_expression = Core.Name "expression" - -_FinalizerBody_empty = Core.Name "empty" - --- | A finalizer (destructor) declaration, with its extern/unsafe flags, name, and body. -data FinalizerDeclaration = - FinalizerDeclaration { - finalizerDeclarationAttributes :: (Maybe Attributes), - finalizerDeclarationExtern :: Bool, - finalizerDeclarationUnsafe :: Bool, - finalizerDeclarationName :: Identifier, - finalizerDeclarationBody :: FinalizerBody} - deriving (Eq, Ord, Read, Show) - -_FinalizerDeclaration = Core.Name "hydra.csharp.syntax.FinalizerDeclaration" - -_FinalizerDeclaration_attributes = Core.Name "attributes" - -_FinalizerDeclaration_extern = Core.Name "extern" - -_FinalizerDeclaration_unsafe = Core.Name "unsafe" - -_FinalizerDeclaration_name = Core.Name "name" - -_FinalizerDeclaration_body = Core.Name "body" - --- | A single by-value or by-reference formal parameter, with optional attributes and a default value. -data FixedParameter = - FixedParameter { - fixedParameterAttributes :: (Maybe Attributes), - fixedParameterModifier :: (Maybe ParameterModifier), - fixedParameterType :: Type, - fixedParameterIdentifier :: Identifier, - fixedParameterDefaultArgument :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_FixedParameter = Core.Name "hydra.csharp.syntax.FixedParameter" - -_FixedParameter_attributes = Core.Name "attributes" - -_FixedParameter_modifier = Core.Name "modifier" - -_FixedParameter_type = Core.Name "type" - -_FixedParameter_identifier = Core.Name "identifier" - -_FixedParameter_defaultArgument = Core.Name "defaultArgument" - --- | A single declarator in a fixed statement, binding a pointer to a variable or expression. -data FixedPointerDeclarator = - FixedPointerDeclaratorReference VariableReference | - FixedPointerDeclaratorExpression Expression - deriving (Eq, Ord, Read, Show) - -_FixedPointerDeclarator = Core.Name "hydra.csharp.syntax.FixedPointerDeclarator" - -_FixedPointerDeclarator_reference = Core.Name "reference" - -_FixedPointerDeclarator_expression = Core.Name "expression" - --- | An unsafe fixed-size buffer field declaration inside a struct. -data FixedSizeBufferDeclaration = - FixedSizeBufferDeclaration { - fixedSizeBufferDeclarationAttributes :: (Maybe Attributes), - fixedSizeBufferDeclarationModifiers :: [FixedSizeBufferModifier], - fixedSizeBufferDeclarationElementType :: Type, - fixedSizeBufferDeclarationDeclarators :: [FixedSizeBufferDeclarator]} - deriving (Eq, Ord, Read, Show) - -_FixedSizeBufferDeclaration = Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration" - -_FixedSizeBufferDeclaration_attributes = Core.Name "attributes" - -_FixedSizeBufferDeclaration_modifiers = Core.Name "modifiers" - -_FixedSizeBufferDeclaration_elementType = Core.Name "elementType" - -_FixedSizeBufferDeclaration_declarators = Core.Name "declarators" - --- | The name and constant size of a single fixed-size buffer member. -data FixedSizeBufferDeclarator = - FixedSizeBufferDeclarator { - fixedSizeBufferDeclaratorName :: Identifier, - fixedSizeBufferDeclaratorSize :: ConstantExpression} - deriving (Eq, Ord, Read, Show) - -_FixedSizeBufferDeclarator = Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator" - -_FixedSizeBufferDeclarator_name = Core.Name "name" - -_FixedSizeBufferDeclarator_size = Core.Name "size" - --- | An access or unsafe modifier on a fixed-size buffer declaration. -data FixedSizeBufferModifier = - FixedSizeBufferModifierNew | - FixedSizeBufferModifierPublic | - FixedSizeBufferModifierInternal | - FixedSizeBufferModifierPrivate | - FixedSizeBufferModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_FixedSizeBufferModifier = Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier" - -_FixedSizeBufferModifier_new = Core.Name "new" - -_FixedSizeBufferModifier_public = Core.Name "public" - -_FixedSizeBufferModifier_internal = Core.Name "internal" - -_FixedSizeBufferModifier_private = Core.Name "private" - -_FixedSizeBufferModifier_unsafe = Core.Name "unsafe" - --- | An unsafe 'fixed' statement that pins one or more variables for pointer access. -data FixedStatement = - FixedStatement { - fixedStatementPointerType :: PointerType, - fixedStatementDeclarators :: [FixedPointerDeclarator], - fixedStatementStatement :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_FixedStatement = Core.Name "hydra.csharp.syntax.FixedStatement" - -_FixedStatement_pointerType = Core.Name "pointerType" - -_FixedStatement_declarators = Core.Name "declarators" - -_FixedStatement_statement = Core.Name "statement" - --- | The float or double floating-point numeric type. -data FloatingPointType = - FloatingPointTypeFloat | - FloatingPointTypeDouble - deriving (Eq, Ord, Read, Show) - -_FloatingPointType = Core.Name "hydra.csharp.syntax.FloatingPointType" - -_FloatingPointType_float = Core.Name "float" - -_FloatingPointType_double = Core.Name "double" - --- | The initializer clause of a for statement: a local variable declaration or expression list. -data ForInitializer = - ForInitializerVariable LocalVariableDeclaration | - ForInitializerStatements StatementExpressionList - deriving (Eq, Ord, Read, Show) - -_ForInitializer = Core.Name "hydra.csharp.syntax.ForInitializer" - -_ForInitializer_variable = Core.Name "variable" - -_ForInitializer_statements = Core.Name "statements" - --- | A C-style for loop, with optional initializer, condition, iterator, and a body statement. -data ForStatement = - ForStatement { - forStatementInitializer :: (Maybe ForInitializer), - forStatementCondition :: (Maybe BooleanExpression), - forStatementIterator :: (Maybe StatementExpressionList), - forStatementBody :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_ForStatement = Core.Name "hydra.csharp.syntax.ForStatement" - -_ForStatement_initializer = Core.Name "initializer" - -_ForStatement_condition = Core.Name "condition" - -_ForStatement_iterator = Core.Name "iterator" - -_ForStatement_body = Core.Name "body" - --- | A foreach iteration statement over an enumerable expression, binding each element to a variable. -data ForeachStatement = - ForeachStatement { - foreachStatementKind :: (Maybe RefKind), - foreachStatementType :: LocalVariableType, - foreachStatementIdentifier :: Identifier, - foreachStatementExpression :: Expression, - foreachStatementBody :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_ForeachStatement = Core.Name "hydra.csharp.syntax.ForeachStatement" - -_ForeachStatement_kind = Core.Name "kind" - -_ForeachStatement_type = Core.Name "type" - -_ForeachStatement_identifier = Core.Name "identifier" - -_ForeachStatement_expression = Core.Name "expression" - -_ForeachStatement_body = Core.Name "body" - --- | The fixed parameters of a member, plus an optional trailing params array parameter. -data FormalParameterList = - FormalParameterList { - formalParameterListFixed :: [FixedParameter], - formalParameterListArray :: (Maybe ParameterArray)} - deriving (Eq, Ord, Read, Show) - -_FormalParameterList = Core.Name "hydra.csharp.syntax.FormalParameterList" - -_FormalParameterList_fixed = Core.Name "fixed" - -_FormalParameterList_array = Core.Name "array" - --- | The initial or additional 'from' clause of a query expression, introducing a range variable. -data FromClause = - FromClause { - fromClauseType :: (Maybe Type), - fromClauseIdentifier :: Identifier, - fromClauseIn :: Expression} - deriving (Eq, Ord, Read, Show) - -_FromClause = Core.Name "hydra.csharp.syntax.FromClause" - -_FromClause_type = Core.Name "type" - -_FromClause_identifier = Core.Name "identifier" - -_FromClause_in = Core.Name "in" - --- | An assembly- or module-level attribute section appearing at the top of a compilation unit. -data GlobalAttributeSection = - GlobalAttributeSection { - globalAttributeSectionTarget :: Identifier, - globalAttributeSectionAttributes :: AttributeList} - deriving (Eq, Ord, Read, Show) - -_GlobalAttributeSection = Core.Name "hydra.csharp.syntax.GlobalAttributeSection" - -_GlobalAttributeSection_target = Core.Name "target" - -_GlobalAttributeSection_attributes = Core.Name "attributes" - --- | A goto statement targeting a label, a switch case, or the switch default section. -data GotoStatement = - GotoStatementIdentifier Identifier | - GotoStatementCase ConstantExpression | - GotoStatementDefault - deriving (Eq, Ord, Read, Show) - -_GotoStatement = Core.Name "hydra.csharp.syntax.GotoStatement" - -_GotoStatement_identifier = Core.Name "identifier" - -_GotoStatement_case = Core.Name "case" - -_GotoStatement_default = Core.Name "default" - --- | The 'group ... by ...' clause that ends a query expression, producing grouped results. -data GroupClause = - GroupClause { - groupClauseGrouped :: Expression, - groupClauseBy :: Expression} - deriving (Eq, Ord, Read, Show) - -_GroupClause = Core.Name "hydra.csharp.syntax.GroupClause" - -_GroupClause_grouped = Core.Name "grouped" - -_GroupClause_by = Core.Name "by" - --- | A C# identifier: a name for a variable, type, member, or other program element. -newtype Identifier = - Identifier { - unIdentifier :: String} - deriving (Eq, Ord, Read, Show) - -_Identifier = Core.Name "hydra.csharp.syntax.Identifier" - --- | A simple namespace-or-type name consisting of an identifier and optional type arguments. -data IdentifierNamespaceOrTypeName = - IdentifierNamespaceOrTypeName { - identifierNamespaceOrTypeNameIdentifier :: Identifier, - identifierNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_IdentifierNamespaceOrTypeName = Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName" - -_IdentifierNamespaceOrTypeName_identifier = Core.Name "identifier" - -_IdentifierNamespaceOrTypeName_arguments = Core.Name "arguments" - --- | An if statement with a boolean condition, a then-branch, and an else-branch. -data IfStatement = - IfStatement { - ifStatementCondition :: BooleanExpression, - ifStatementIfBranch :: EmbeddedStatement, - ifStatementElseBranch :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_IfStatement = Core.Name "hydra.csharp.syntax.IfStatement" - -_IfStatement_condition = Core.Name "condition" - -_IfStatement_ifBranch = Core.Name "ifBranch" - -_IfStatement_elseBranch = Core.Name "elseBranch" - --- | A local variable declaration using 'var' with inferred type, plain or ref. -data ImplicitlyTypedLocalVariableDeclaration = - ImplicitlyTypedLocalVariableDeclarationVar ImplicitlyTypedLocalVariableDeclarator | - ImplicitlyTypedLocalVariableDeclarationRefVar RefVarImplicitlyTypedLocalVariableDeclaration - deriving (Eq, Ord, Read, Show) - -_ImplicitlyTypedLocalVariableDeclaration = Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration" - -_ImplicitlyTypedLocalVariableDeclaration_var = Core.Name "var" - -_ImplicitlyTypedLocalVariableDeclaration_refVar = Core.Name "refVar" - --- | The identifier and initializer expression of a 'var'-typed local variable. -data ImplicitlyTypedLocalVariableDeclarator = - ImplicitlyTypedLocalVariableDeclarator { - implicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier, - implicitlyTypedLocalVariableDeclaratorExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_ImplicitlyTypedLocalVariableDeclarator = Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator" - -_ImplicitlyTypedLocalVariableDeclarator_identifier = Core.Name "identifier" - -_ImplicitlyTypedLocalVariableDeclarator_expression = Core.Name "expression" - --- | A simple exclusive-OR expression or a binary bitwise inclusive-OR (|) expression. -data InclusiveOrExpression = - InclusiveOrExpressionSimple ExclusiveOrExpression | - InclusiveOrExpressionBinary BinaryInclusiveOrExpression - deriving (Eq, Ord, Read, Show) - -_InclusiveOrExpression = Core.Name "hydra.csharp.syntax.InclusiveOrExpression" - -_InclusiveOrExpression_simple = Core.Name "simple" - -_InclusiveOrExpression_binary = Core.Name "binary" - --- | The body of a standard indexer: block accessors or a single expression body. -data IndexerBody = - IndexerBodyBlock AccessorDeclarations | - IndexerBodyExpression Expression - deriving (Eq, Ord, Read, Show) - -_IndexerBody = Core.Name "hydra.csharp.syntax.IndexerBody" - -_IndexerBody_block = Core.Name "block" - -_IndexerBody_expression = Core.Name "expression" - --- | An indexer member declaration, in its standard or ref-returning form. -data IndexerDeclaration = - IndexerDeclarationStandard StandardIndexerDeclaration | - IndexerDeclarationRef RefIndexerDeclaration - deriving (Eq, Ord, Read, Show) - -_IndexerDeclaration = Core.Name "hydra.csharp.syntax.IndexerDeclaration" - -_IndexerDeclaration_standard = Core.Name "standard" - -_IndexerDeclaration_ref = Core.Name "ref" - --- | An indexer's declared type, optional explicit interface, and formal parameter list. -data IndexerDeclarator = - IndexerDeclarator { - indexerDeclaratorType :: Type, - indexerDeclaratorInterface :: (Maybe InterfaceType), - indexerDeclaratorParameters :: FormalParameterList} - deriving (Eq, Ord, Read, Show) - -_IndexerDeclarator = Core.Name "hydra.csharp.syntax.IndexerDeclarator" - -_IndexerDeclarator_type = Core.Name "type" - -_IndexerDeclarator_interface = Core.Name "interface" - -_IndexerDeclarator_parameters = Core.Name "parameters" - --- | A modifier keyword on an indexer declaration, such as virtual, override, or abstract. -data IndexerModifier = - IndexerModifierNew | - IndexerModifierPublic | - IndexerModifierProtected | - IndexerModifierInternal | - IndexerModifierPrivate | - IndexerModifierVirtual | - IndexerModifierSealed | - IndexerModifierOverride | - IndexerModifierAbstract | - IndexerModifierExtern | - IndexerModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_IndexerModifier = Core.Name "hydra.csharp.syntax.IndexerModifier" - -_IndexerModifier_new = Core.Name "new" - -_IndexerModifier_public = Core.Name "public" - -_IndexerModifier_protected = Core.Name "protected" - -_IndexerModifier_internal = Core.Name "internal" - -_IndexerModifier_private = Core.Name "private" - -_IndexerModifier_virtual = Core.Name "virtual" - -_IndexerModifier_sealed = Core.Name "sealed" - -_IndexerModifier_override = Core.Name "override" - -_IndexerModifier_abstract = Core.Name "abstract" - -_IndexerModifier_extern = Core.Name "extern" - -_IndexerModifier_unsafe = Core.Name "unsafe" - --- | The left-hand side of a member initializer: an identifier or an indexer argument list. -data InitializerTarget = - InitializerTargetIdentifier Identifier | - InitializerTargetArguments ArgumentList - deriving (Eq, Ord, Read, Show) - -_InitializerTarget = Core.Name "hydra.csharp.syntax.InitializerTarget" - -_InitializerTarget_identifier = Core.Name "identifier" - -_InitializerTarget_arguments = Core.Name "arguments" - --- | The right-hand side of a member initializer: an expression or a nested collection initializer. -data InitializerValue = - InitializerValueExpression Expression | - InitializerValueObjectOrCollection ObjectOrCollectionInitializer - deriving (Eq, Ord, Read, Show) - -_InitializerValue = Core.Name "hydra.csharp.syntax.InitializerValue" - -_InitializerValue_expression = Core.Name "expression" - -_InitializerValue_objectOrCollection = Core.Name "objectOrCollection" - --- | An integer literal, expressed in decimal, hexadecimal, or binary notation. -data IntegerLiteral = - IntegerLiteralDecimal String | - IntegerLiteralHexadecimal String | - IntegerLiteralBinary Integer - deriving (Eq, Ord, Read, Show) - -_IntegerLiteral = Core.Name "hydra.csharp.syntax.IntegerLiteral" - -_IntegerLiteral_decimal = Core.Name "decimal" - -_IntegerLiteral_hexadecimal = Core.Name "hexadecimal" - -_IntegerLiteral_binary = Core.Name "binary" - --- | One of the built-in integral numeric types (sbyte through char). -data IntegralType = - IntegralTypeSbyte | - IntegralTypeByte | - IntegralTypeShort | - IntegralTypeUshort | - IntegralTypeInt | - IntegralTypeUint | - IntegralTypeLong | - IntegralTypeUlong | - IntegralTypeChar - deriving (Eq, Ord, Read, Show) - -_IntegralType = Core.Name "hydra.csharp.syntax.IntegralType" - -_IntegralType_sbyte = Core.Name "sbyte" - -_IntegralType_byte = Core.Name "byte" - -_IntegralType_short = Core.Name "short" - -_IntegralType_ushort = Core.Name "ushort" - -_IntegralType_int = Core.Name "int" - -_IntegralType_uint = Core.Name "uint" - -_IntegralType_long = Core.Name "long" - -_IntegralType_ulong = Core.Name "ulong" - -_IntegralType_char = Core.Name "char" - --- | The get and/or set accessor attribute lists declared by an interface property or indexer. -data InterfaceAccessors = - InterfaceAccessors { - interfaceAccessorsAttributes :: (Maybe Attributes), - interfaceAccessorsGet :: (Maybe Attributes), - interfaceAccessorsSet :: (Maybe Attributes)} - deriving (Eq, Ord, Read, Show) - -_InterfaceAccessors = Core.Name "hydra.csharp.syntax.InterfaceAccessors" - -_InterfaceAccessors_attributes = Core.Name "attributes" - -_InterfaceAccessors_get = Core.Name "get" - -_InterfaceAccessors_set = Core.Name "set" - --- | An interface type declaration, with its modifiers, type parameters, base interfaces, and members. -data InterfaceDeclaration = - InterfaceDeclaration { - interfaceDeclarationAttributes :: (Maybe Attributes), - interfaceDeclarationModifiers :: [InterfaceModifier], - interfaceDeclarationPartial :: Bool, - interfaceDeclarationName :: Identifier, - interfaceDeclarationParameters :: (Maybe VariantTypeParameters), - interfaceDeclarationBase :: [InterfaceType], - interfaceDeclarationConstraints :: [TypeParameterConstraintsClause], - interfaceDeclarationBody :: [InterfaceMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_InterfaceDeclaration = Core.Name "hydra.csharp.syntax.InterfaceDeclaration" - -_InterfaceDeclaration_attributes = Core.Name "attributes" - -_InterfaceDeclaration_modifiers = Core.Name "modifiers" - -_InterfaceDeclaration_partial = Core.Name "partial" - -_InterfaceDeclaration_name = Core.Name "name" - -_InterfaceDeclaration_parameters = Core.Name "parameters" - -_InterfaceDeclaration_base = Core.Name "base" - -_InterfaceDeclaration_constraints = Core.Name "constraints" - -_InterfaceDeclaration_body = Core.Name "body" - --- | An event member declared within an interface body. -data InterfaceEventDeclaration = - InterfaceEventDeclaration { - interfaceEventDeclarationAttributes :: (Maybe Attributes), - interfaceEventDeclarationNew :: Bool, - interfaceEventDeclarationType :: Type, - interfaceEventDeclarationName :: Identifier} - deriving (Eq, Ord, Read, Show) - -_InterfaceEventDeclaration = Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration" - -_InterfaceEventDeclaration_attributes = Core.Name "attributes" - -_InterfaceEventDeclaration_new = Core.Name "new" - -_InterfaceEventDeclaration_type = Core.Name "type" - -_InterfaceEventDeclaration_name = Core.Name "name" - --- | An indexer member declared within an interface body. -data InterfaceIndexerDeclaration = - InterfaceIndexerDeclaration { - interfaceIndexerDeclarationAttributes :: (Maybe Attributes), - interfaceIndexerDeclarationNew :: Bool, - interfaceIndexerDeclarationRefKind :: (Maybe RefKind), - interfaceIndexerDeclarationType :: Type, - interfaceIndexerDeclarationParameters :: FormalParameterList, - interfaceIndexerDeclarationAccessors :: InterfaceAccessors} - deriving (Eq, Ord, Read, Show) - -_InterfaceIndexerDeclaration = Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration" - -_InterfaceIndexerDeclaration_attributes = Core.Name "attributes" - -_InterfaceIndexerDeclaration_new = Core.Name "new" - -_InterfaceIndexerDeclaration_refKind = Core.Name "refKind" - -_InterfaceIndexerDeclaration_type = Core.Name "type" - -_InterfaceIndexerDeclaration_parameters = Core.Name "parameters" - -_InterfaceIndexerDeclaration_accessors = Core.Name "accessors" - --- | Any member that can appear in an interface body: method, property, event, or indexer. -data InterfaceMemberDeclaration = - InterfaceMemberDeclarationMethod InterfaceMethodDeclaration | - InterfaceMemberDeclarationProperty InterfacePropertyDeclaration | - InterfaceMemberDeclarationEvent InterfaceEventDeclaration | - InterfaceMemberDeclarationIndexer InterfaceIndexerDeclaration - deriving (Eq, Ord, Read, Show) - -_InterfaceMemberDeclaration = Core.Name "hydra.csharp.syntax.InterfaceMemberDeclaration" - -_InterfaceMemberDeclaration_method = Core.Name "method" - -_InterfaceMemberDeclaration_property = Core.Name "property" - -_InterfaceMemberDeclaration_event = Core.Name "event" - -_InterfaceMemberDeclaration_indexer = Core.Name "indexer" - --- | A method member declared within an interface body. -data InterfaceMethodDeclaration = - InterfaceMethodDeclaration { - interfaceMethodDeclarationAttributes :: (Maybe Attributes), - interfaceMethodDeclarationNew :: Bool, - interfaceMethodDeclarationReturnType :: ReturnType, - interfaceMethodDeclarationRefKind :: (Maybe RefKind), - interfaceMethodDeclarationHeader :: InterfaceMethodHeader} - deriving (Eq, Ord, Read, Show) - -_InterfaceMethodDeclaration = Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration" - -_InterfaceMethodDeclaration_attributes = Core.Name "attributes" - -_InterfaceMethodDeclaration_new = Core.Name "new" - -_InterfaceMethodDeclaration_returnType = Core.Name "returnType" - -_InterfaceMethodDeclaration_refKind = Core.Name "refKind" - -_InterfaceMethodDeclaration_header = Core.Name "header" - --- | The name, parameters, type parameters, and constraints of an interface method declaration. -data InterfaceMethodHeader = - InterfaceMethodHeader { - interfaceMethodHeaderName :: Identifier, - interfaceMethodHeaderParameters :: (Maybe FormalParameterList), - interfaceMethodHeaderTypeParameters :: (Maybe TypeParameterList), - interfaceMethodHeaderConstraints :: [TypeParameterConstraintsClause]} - deriving (Eq, Ord, Read, Show) - -_InterfaceMethodHeader = Core.Name "hydra.csharp.syntax.InterfaceMethodHeader" - -_InterfaceMethodHeader_name = Core.Name "name" - -_InterfaceMethodHeader_parameters = Core.Name "parameters" - -_InterfaceMethodHeader_typeParameters = Core.Name "typeParameters" - -_InterfaceMethodHeader_constraints = Core.Name "constraints" - --- | An access or unsafe modifier on an interface declaration. -data InterfaceModifier = - InterfaceModifierNew | - InterfaceModifierPublic | - InterfaceModifierProtected | - InterfaceModifierInternal | - InterfaceModifierPrivate | - InterfaceModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_InterfaceModifier = Core.Name "hydra.csharp.syntax.InterfaceModifier" - -_InterfaceModifier_new = Core.Name "new" - -_InterfaceModifier_public = Core.Name "public" - -_InterfaceModifier_protected = Core.Name "protected" - -_InterfaceModifier_internal = Core.Name "internal" - -_InterfaceModifier_private = Core.Name "private" - -_InterfaceModifier_unsafe = Core.Name "unsafe" - --- | A property member declared within an interface body. -data InterfacePropertyDeclaration = - InterfacePropertyDeclaration { - interfacePropertyDeclarationAttributes :: (Maybe Attributes), - interfacePropertyDeclarationNew :: Bool, - interfacePropertyDeclarationRefKind :: (Maybe RefKind), - interfacePropertyDeclarationType :: Type, - interfacePropertyDeclarationName :: Identifier, - interfacePropertyDeclarationAccessors :: InterfaceAccessors} - deriving (Eq, Ord, Read, Show) - -_InterfacePropertyDeclaration = Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration" - -_InterfacePropertyDeclaration_attributes = Core.Name "attributes" - -_InterfacePropertyDeclaration_new = Core.Name "new" - -_InterfacePropertyDeclaration_refKind = Core.Name "refKind" - -_InterfacePropertyDeclaration_type = Core.Name "type" - -_InterfacePropertyDeclaration_name = Core.Name "name" - -_InterfacePropertyDeclaration_accessors = Core.Name "accessors" - --- | A reference to an interface type by its type name. -newtype InterfaceType = - InterfaceType { - unInterfaceType :: TypeName} - deriving (Eq, Ord, Read, Show) - -_InterfaceType = Core.Name "hydra.csharp.syntax.InterfaceType" - --- | An interpolated string literal delimited by ordinary double quotes. -newtype InterpolatedRegularStringExpression = - InterpolatedRegularStringExpression { - unInterpolatedRegularStringExpression :: String} - deriving (Eq, Ord, Read, Show) - -_InterpolatedRegularStringExpression = Core.Name "hydra.csharp.syntax.InterpolatedRegularStringExpression" - --- | An interpolated string expression, in its regular or verbatim quoting form. -data InterpolatedStringExpression = - InterpolatedStringExpressionRegular InterpolatedRegularStringExpression | - InterpolatedStringExpressionVerbatim InterpolatedVerbatimStringExpression - deriving (Eq, Ord, Read, Show) - -_InterpolatedStringExpression = Core.Name "hydra.csharp.syntax.InterpolatedStringExpression" - -_InterpolatedStringExpression_regular = Core.Name "regular" - -_InterpolatedStringExpression_verbatim = Core.Name "verbatim" - --- | An interpolated string literal using verbatim, at-sign-prefixed quoting. -newtype InterpolatedVerbatimStringExpression = - InterpolatedVerbatimStringExpression { - unInterpolatedVerbatimStringExpression :: String} - deriving (Eq, Ord, Read, Show) - -_InterpolatedVerbatimStringExpression = Core.Name "hydra.csharp.syntax.InterpolatedVerbatimStringExpression" - --- | A method or delegate invocation: a primary expression applied to an argument list. -data InvocationExpression = - InvocationExpression { - invocationExpressionExpression :: PrimaryExpression, - invocationExpressionArguments :: (Maybe ArgumentList)} - deriving (Eq, Ord, Read, Show) - -_InvocationExpression = Core.Name "hydra.csharp.syntax.InvocationExpression" - -_InvocationExpression_expression = Core.Name "expression" - -_InvocationExpression_arguments = Core.Name "arguments" - --- | An 'is' pattern-matching expression testing a relational expression against a pattern. -data IsPatternExpression = - IsPatternExpression { - isPatternExpressionExpression :: RelationalExpression, - isPatternExpressionPattern :: Pattern} - deriving (Eq, Ord, Read, Show) - -_IsPatternExpression = Core.Name "hydra.csharp.syntax.IsPatternExpression" - -_IsPatternExpression_expression = Core.Name "expression" - -_IsPatternExpression_pattern = Core.Name "pattern" - --- | An 'is' type-testing expression checking whether an expression is of a given type. -data IsTypeExpression = - IsTypeExpression { - isTypeExpressionExpression :: RelationalExpression, - isTypeExpressionType :: Type} - deriving (Eq, Ord, Read, Show) - -_IsTypeExpression = Core.Name "hydra.csharp.syntax.IsTypeExpression" - -_IsTypeExpression_expression = Core.Name "expression" - -_IsTypeExpression_type = Core.Name "type" - --- | A while, do, for, or foreach loop statement. -data IterationStatement = - IterationStatementWhile WhileStatement | - IterationStatementDo DoStatement | - IterationStatementFor ForStatement | - IterationStatementForeach ForeachStatement - deriving (Eq, Ord, Read, Show) - -_IterationStatement = Core.Name "hydra.csharp.syntax.IterationStatement" - -_IterationStatement_while = Core.Name "while" - -_IterationStatement_do = Core.Name "do" - -_IterationStatement_for = Core.Name "for" - -_IterationStatement_foreach = Core.Name "foreach" - --- | A 'join' clause in a query expression, correlating two sequences on matching keys. -data JoinClause = - JoinClause { - joinClauseType :: (Maybe Type), - joinClauseIdentifier :: Identifier, - joinClauseIn :: Expression, - joinClauseOn :: Expression, - joinClauseEquals :: Expression, - joinClauseInto :: (Maybe Identifier)} - deriving (Eq, Ord, Read, Show) - -_JoinClause = Core.Name "hydra.csharp.syntax.JoinClause" - -_JoinClause_type = Core.Name "type" - -_JoinClause_identifier = Core.Name "identifier" - -_JoinClause_in = Core.Name "in" - -_JoinClause_on = Core.Name "on" - -_JoinClause_equals = Core.Name "equals" - -_JoinClause_into = Core.Name "into" - --- | A break, continue, goto, return, or throw statement that transfers control. -data JumpStatement = - JumpStatementBreak | - JumpStatementContinue | - JumpStatementGoto GotoStatement | - JumpStatementReturn ReturnStatement | - JumpStatementThrow (Maybe Expression) - deriving (Eq, Ord, Read, Show) - -_JumpStatement = Core.Name "hydra.csharp.syntax.JumpStatement" - -_JumpStatement_break = Core.Name "break" - -_JumpStatement_continue = Core.Name "continue" - -_JumpStatement_goto = Core.Name "goto" - -_JumpStatement_return = Core.Name "return" - -_JumpStatement_throw = Core.Name "throw" - --- | A reserved C# keyword. -newtype Keyword = - Keyword { - unKeyword :: String} - deriving (Eq, Ord, Read, Show) - -_Keyword = Core.Name "hydra.csharp.syntax.Keyword" - --- | A statement prefixed with a label, usable as the target of a goto statement. -data LabeledStatement = - LabeledStatement { - labeledStatementLabel :: Identifier, - labeledStatementStatement :: Statement} - deriving (Eq, Ord, Read, Show) - -_LabeledStatement = Core.Name "hydra.csharp.syntax.LabeledStatement" - -_LabeledStatement_label = Core.Name "label" - -_LabeledStatement_statement = Core.Name "statement" - --- | A lambda expression, with its async flag, parameter signature, and body. -data LambdaExpression = - LambdaExpression { - lambdaExpressionAsync :: Bool, - lambdaExpressionSignature :: AnonymousFunctionSignature, - lambdaExpressionBody :: AnonymousFunctionBody} - deriving (Eq, Ord, Read, Show) - -_LambdaExpression = Core.Name "hydra.csharp.syntax.LambdaExpression" - -_LambdaExpression_async = Core.Name "async" - -_LambdaExpression_signature = Core.Name "signature" - -_LambdaExpression_body = Core.Name "body" - --- | A 'let' clause in a query expression that introduces a computed range variable. -data LetClause = - LetClause { - letClauseLeft :: Identifier, - letClauseRight :: Expression} - deriving (Eq, Ord, Read, Show) - -_LetClause = Core.Name "hydra.csharp.syntax.LetClause" - -_LetClause_left = Core.Name "left" - -_LetClause_right = Core.Name "right" - --- | A literal value: boolean, integer, real, character, string, or null. -data Literal = - LiteralBoolean Bool | - LiteralInteger IntegerLiteral | - LiteralReal Double | - LiteralCharacter String | - LiteralString String | - LiteralNull - deriving (Eq, Ord, Read, Show) - -_Literal = Core.Name "hydra.csharp.syntax.Literal" - -_Literal_boolean = Core.Name "boolean" - -_Literal_integer = Core.Name "integer" - -_Literal_real = Core.Name "real" - -_Literal_character = Core.Name "character" - -_Literal_string = Core.Name "string" - -_Literal_null = Core.Name "null" - --- | A 'const' local declaration with its type and one or more constant declarators. -data LocalConstantDeclaration = - LocalConstantDeclaration { - localConstantDeclarationType :: Type, - localConstantDeclarationDeclarators :: [ConstantDeclarator]} - deriving (Eq, Ord, Read, Show) - -_LocalConstantDeclaration = Core.Name "hydra.csharp.syntax.LocalConstantDeclaration" - -_LocalConstantDeclaration_type = Core.Name "type" - -_LocalConstantDeclaration_declarators = Core.Name "declarators" - --- | The body of a local function: a block, null-conditional invocation, or expression. -data LocalFunctionBody = - LocalFunctionBodyBlock Block | - LocalFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression | - LocalFunctionBodyExpression Expression - deriving (Eq, Ord, Read, Show) - -_LocalFunctionBody = Core.Name "hydra.csharp.syntax.LocalFunctionBody" - -_LocalFunctionBody_block = Core.Name "block" - -_LocalFunctionBody_nullConditionalInvocation = Core.Name "nullConditionalInvocation" - -_LocalFunctionBody_expression = Core.Name "expression" - --- | A local function declaration, in its standard or ref-returning form. -data LocalFunctionDeclaration = - LocalFunctionDeclarationStandard StandardLocalFunctionDeclaration | - LocalFunctionDeclarationRef RefLocalFunctionDeclaration - deriving (Eq, Ord, Read, Show) - -_LocalFunctionDeclaration = Core.Name "hydra.csharp.syntax.LocalFunctionDeclaration" - -_LocalFunctionDeclaration_standard = Core.Name "standard" - -_LocalFunctionDeclaration_ref = Core.Name "ref" - --- | The name, type parameters, formal parameters, and constraints of a local function. -data LocalFunctionHeader = - LocalFunctionHeader { - localFunctionHeaderIdentifier :: Identifier, - localFunctionHeaderTypeParameters :: (Maybe TypeParameterList), - localFunctionHeaderParameters :: FormalParameterList, - localFunctionHeaderConstraints :: [TypeParameterConstraintsClause]} - deriving (Eq, Ord, Read, Show) - -_LocalFunctionHeader = Core.Name "hydra.csharp.syntax.LocalFunctionHeader" - -_LocalFunctionHeader_identifier = Core.Name "identifier" - -_LocalFunctionHeader_typeParameters = Core.Name "typeParameters" - -_LocalFunctionHeader_parameters = Core.Name "parameters" - -_LocalFunctionHeader_constraints = Core.Name "constraints" - --- | A modifier on a local function declaration: a ref modifier, or 'async'. -data LocalFunctionModifier = - LocalFunctionModifierRef RefLocalFunctionModifier | - LocalFunctionModifierAsync - deriving (Eq, Ord, Read, Show) - -_LocalFunctionModifier = Core.Name "hydra.csharp.syntax.LocalFunctionModifier" - -_LocalFunctionModifier_ref = Core.Name "ref" - -_LocalFunctionModifier_async = Core.Name "async" - --- | A local variable declaration, in its implicitly typed, explicitly typed, or ref form. -data LocalVariableDeclaration = - LocalVariableDeclarationImplicitlyTyped ImplicitlyTypedLocalVariableDeclaration | - LocalVariableDeclarationExplicitlyTyped ExplicitlyTypedLocalVariableDeclaration | - LocalVariableDeclarationRef RefLocalVariableDeclaration - deriving (Eq, Ord, Read, Show) - -_LocalVariableDeclaration = Core.Name "hydra.csharp.syntax.LocalVariableDeclaration" - -_LocalVariableDeclaration_implicitlyTyped = Core.Name "implicitlyTyped" - -_LocalVariableDeclaration_explicitlyTyped = Core.Name "explicitlyTyped" - -_LocalVariableDeclaration_ref = Core.Name "ref" - --- | The initializer of a local variable: an expression or an array initializer. -data LocalVariableInitializer = - LocalVariableInitializerExpression Expression | - LocalVariableInitializerInitializer ArrayInitializer - deriving (Eq, Ord, Read, Show) - -_LocalVariableInitializer = Core.Name "hydra.csharp.syntax.LocalVariableInitializer" - -_LocalVariableInitializer_expression = Core.Name "expression" - -_LocalVariableInitializer_initializer = Core.Name "initializer" - --- | The declared type of a local variable, or 'var' for implicit typing. -data LocalVariableType = - LocalVariableTypeType Type | - LocalVariableTypeVar - deriving (Eq, Ord, Read, Show) - -_LocalVariableType = Core.Name "hydra.csharp.syntax.LocalVariableType" - -_LocalVariableType_type = Core.Name "type" - -_LocalVariableType_var = Core.Name "var" - --- | A 'lock' statement that acquires a mutual-exclusion lock for the duration of its body. -data LockStatement = - LockStatement { - lockStatementExpression :: Expression, - lockStatementBody :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_LockStatement = Core.Name "hydra.csharp.syntax.LockStatement" - -_LockStatement_expression = Core.Name "expression" - -_LockStatement_body = Core.Name "body" - --- | A 'primary.identifier' member access, with optional explicit type arguments. -data MemberAccess = - MemberAccess { - memberAccessHead :: MemberAccessHead, - memberAccessIdentifier :: Identifier, - memberAccessTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_MemberAccess = Core.Name "hydra.csharp.syntax.MemberAccess" - -_MemberAccess_head = Core.Name "head" - -_MemberAccess_identifier = Core.Name "identifier" - -_MemberAccess_typeArguments = Core.Name "typeArguments" - --- | The left-hand target of a member access: a primary expression, predefined type, or alias. -data MemberAccessHead = - MemberAccessHeadPrimary PrimaryExpression | - MemberAccessHeadPredefined PredefinedType | - MemberAccessHeadQualifiedAlias QualifiedAliasMember - deriving (Eq, Ord, Read, Show) - -_MemberAccessHead = Core.Name "hydra.csharp.syntax.MemberAccessHead" - -_MemberAccessHead_primary = Core.Name "primary" - -_MemberAccessHead_predefined = Core.Name "predefined" - -_MemberAccessHead_qualifiedAlias = Core.Name "qualifiedAlias" - --- | A single member of an anonymous object initializer, naming or computing a member value. -data MemberDeclarator = - MemberDeclaratorName SimpleName | - MemberDeclaratorMemberAccess MemberAccess | - MemberDeclaratorNullConditionalProjectionInitializer NullConditionalProjectionInitializer | - MemberDeclaratorBaseAccess BaseAccess | - MemberDeclaratorAssignment AssignmentMemberDeclarator - deriving (Eq, Ord, Read, Show) - -_MemberDeclarator = Core.Name "hydra.csharp.syntax.MemberDeclarator" - -_MemberDeclarator_name = Core.Name "name" - -_MemberDeclarator_memberAccess = Core.Name "memberAccess" - -_MemberDeclarator_nullConditionalProjectionInitializer = Core.Name "nullConditionalProjectionInitializer" - -_MemberDeclarator_baseAccess = Core.Name "baseAccess" - -_MemberDeclarator_assignment = Core.Name "assignment" - --- | A non-empty, comma-separated list of member declarators in an anonymous object creation. -newtype MemberDeclaratorList = - MemberDeclaratorList { - unMemberDeclaratorList :: [MemberDeclarator]} - deriving (Eq, Ord, Read, Show) - -_MemberDeclaratorList = Core.Name "hydra.csharp.syntax.MemberDeclaratorList" - --- | A 'target = value' pair within an object initializer. -data MemberInitializer = - MemberInitializer { - memberInitializerTarget :: InitializerTarget, - memberInitializerValue :: InitializerValue} - deriving (Eq, Ord, Read, Show) - -_MemberInitializer = Core.Name "hydra.csharp.syntax.MemberInitializer" - -_MemberInitializer_target = Core.Name "target" - -_MemberInitializer_value = Core.Name "value" - --- | A member's declared name, with an optional explicit interface type qualifier. -data MemberName = - MemberName { - memberNameInterfaceType :: (Maybe TypeName), - memberNameIdentifier :: Identifier} - deriving (Eq, Ord, Read, Show) - -_MemberName = Core.Name "hydra.csharp.syntax.MemberName" - -_MemberName_interfaceType = Core.Name "interfaceType" - -_MemberName_identifier = Core.Name "identifier" - --- | The body of a standard method: a block, null-conditional invocation, expression, or empty. -data MethodBody = - MethodBodyBlock Block | - MethodBodyNullConditionalInvocation NullConditionalInvocationExpression | - MethodBodyExpression Expression | - MethodBodyEmpty - deriving (Eq, Ord, Read, Show) - -_MethodBody = Core.Name "hydra.csharp.syntax.MethodBody" - -_MethodBody_block = Core.Name "block" - -_MethodBody_nullConditionalInvocation = Core.Name "nullConditionalInvocation" - -_MethodBody_expression = Core.Name "expression" - -_MethodBody_empty = Core.Name "empty" - --- | A method member declaration, in its standard or ref-returning form. -data MethodDeclaration = - MethodDeclarationStandard StandardMethodDeclaration | - MethodDeclarationRefReturn RefReturnMethodDeclaration - deriving (Eq, Ord, Read, Show) - -_MethodDeclaration = Core.Name "hydra.csharp.syntax.MethodDeclaration" - -_MethodDeclaration_standard = Core.Name "standard" - -_MethodDeclaration_refReturn = Core.Name "refReturn" - --- | The name, type parameters, formal parameters, and constraints of a method declaration. -data MethodHeader = - MethodHeader { - methodHeaderName :: MemberName, - methodHeaderTypeParameters :: (Maybe TypeParameterList), - methodHeaderParameters :: (Maybe FormalParameterList), - methodHeaderConstraints :: [TypeParameterConstraintsClause]} - deriving (Eq, Ord, Read, Show) - -_MethodHeader = Core.Name "hydra.csharp.syntax.MethodHeader" - -_MethodHeader_name = Core.Name "name" - -_MethodHeader_typeParameters = Core.Name "typeParameters" - -_MethodHeader_parameters = Core.Name "parameters" - -_MethodHeader_constraints = Core.Name "constraints" - --- | A modifier on a method declaration: a ref modifier, or 'async'. -data MethodModifier = - MethodModifierRef RefMethodModifier | - MethodModifierAsync - deriving (Eq, Ord, Read, Show) - -_MethodModifier = Core.Name "hydra.csharp.syntax.MethodModifier" - -_MethodModifier_ref = Core.Name "ref" - -_MethodModifier_async = Core.Name "async" - --- | The full modifier list of a method declaration, including whether it is 'partial'. -data MethodModifiers = - MethodModifiers { - methodModifiersModifiers :: [MethodModifier], - methodModifiersPartial :: Bool} - deriving (Eq, Ord, Read, Show) - -_MethodModifiers = Core.Name "hydra.csharp.syntax.MethodModifiers" - -_MethodModifiers_modifiers = Core.Name "modifiers" - -_MethodModifiers_partial = Core.Name "partial" - --- | A simple unary expression or a binary multiplication/division/remainder expression. -data MultiplicativeExpression = - MultiplicativeExpressionSimple UnaryExpression | - MultiplicativeExpressionBinary BinaryMultiplicativeExpression - deriving (Eq, Ord, Read, Show) - -_MultiplicativeExpression = Core.Name "hydra.csharp.syntax.MultiplicativeExpression" - -_MultiplicativeExpression_simple = Core.Name "simple" - -_MultiplicativeExpression_binary = Core.Name "binary" - --- | The multiplication, division, or modulo operator. -data MultiplicativeOperator = - MultiplicativeOperatorTimes | - MultiplicativeOperatorDivide | - MultiplicativeOperatorModulo - deriving (Eq, Ord, Read, Show) - -_MultiplicativeOperator = Core.Name "hydra.csharp.syntax.MultiplicativeOperator" - -_MultiplicativeOperator_times = Core.Name "times" - -_MultiplicativeOperator_divide = Core.Name "divide" - -_MultiplicativeOperator_modulo = Core.Name "modulo" - --- | An argument of the form 'name: value' passed to an attribute constructor. -data NamedArgument = - NamedArgument { - namedArgumentName :: Identifier, - namedArgumentValue :: AttributeArgumentExpression} - deriving (Eq, Ord, Read, Show) - -_NamedArgument = Core.Name "hydra.csharp.syntax.NamedArgument" - -_NamedArgument_name = Core.Name "name" - -_NamedArgument_value = Core.Name "value" - --- | A non-empty, comma-separated list of named arguments passed to an attribute. -newtype NamedArgumentList = - NamedArgumentList { - unNamedArgumentList :: [NamedArgument]} - deriving (Eq, Ord, Read, Show) - -_NamedArgumentList = Core.Name "hydra.csharp.syntax.NamedArgumentList" - --- | The target expression of a 'nameof' operator, with its chain of accessed parts. -data NamedEntity = - NamedEntity { - namedEntityTarget :: NamedEntityTarget, - namedEntityParts :: [NamedEntityPart]} - deriving (Eq, Ord, Read, Show) - -_NamedEntity = Core.Name "hydra.csharp.syntax.NamedEntity" - -_NamedEntity_target = Core.Name "target" - -_NamedEntity_parts = Core.Name "parts" - --- | A single '.identifier' segment chained within a named entity. -data NamedEntityPart = - NamedEntityPart { - namedEntityPartIdentifier :: Identifier, - namedEntityPartTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_NamedEntityPart = Core.Name "hydra.csharp.syntax.NamedEntityPart" - -_NamedEntityPart_identifier = Core.Name "identifier" - -_NamedEntityPart_typeArguments = Core.Name "typeArguments" - --- | The initial target of a named entity: a simple name, this, base, or a predefined/aliased type. -data NamedEntityTarget = - NamedEntityTargetName SimpleName | - NamedEntityTargetThis | - NamedEntityTargetBase | - NamedEntityTargetPredefinedType PredefinedType | - NamedEntityTargetQualifiedAliasMember QualifiedAliasMember - deriving (Eq, Ord, Read, Show) - -_NamedEntityTarget = Core.Name "hydra.csharp.syntax.NamedEntityTarget" - -_NamedEntityTarget_name = Core.Name "name" - -_NamedEntityTarget_this = Core.Name "this" - -_NamedEntityTarget_base = Core.Name "base" - -_NamedEntityTarget_predefinedType = Core.Name "predefinedType" - -_NamedEntityTarget_qualifiedAliasMember = Core.Name "qualifiedAliasMember" - --- | The extern aliases, using directives, and member declarations within a namespace. -data NamespaceBody = - NamespaceBody { - namespaceBodyExterns :: [ExternAliasDirective], - namespaceBodyUsings :: [UsingDirective], - namespaceBodyMembers :: [NamespaceMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_NamespaceBody = Core.Name "hydra.csharp.syntax.NamespaceBody" - -_NamespaceBody_externs = Core.Name "externs" - -_NamespaceBody_usings = Core.Name "usings" - -_NamespaceBody_members = Core.Name "members" - --- | A namespace declaration, naming the namespace and giving its body. -data NamespaceDeclaration = - NamespaceDeclaration { - namespaceDeclarationName :: QualifiedIdentifier, - namespaceDeclarationBody :: NamespaceBody} - deriving (Eq, Ord, Read, Show) - -_NamespaceDeclaration = Core.Name "hydra.csharp.syntax.NamespaceDeclaration" - -_NamespaceDeclaration_name = Core.Name "name" - -_NamespaceDeclaration_body = Core.Name "body" - --- | A member of a namespace: a nested namespace declaration or a type declaration. -data NamespaceMemberDeclaration = - NamespaceMemberDeclarationNamespace NamespaceDeclaration | - NamespaceMemberDeclarationType TypeDeclaration - deriving (Eq, Ord, Read, Show) - -_NamespaceMemberDeclaration = Core.Name "hydra.csharp.syntax.NamespaceMemberDeclaration" - -_NamespaceMemberDeclaration_namespace = Core.Name "namespace" - -_NamespaceMemberDeclaration_type = Core.Name "type" - --- | A reference to a namespace, expressed as a namespace-or-type name. -newtype NamespaceName = - NamespaceName { - unNamespaceName :: NamespaceOrTypeName} - deriving (Eq, Ord, Read, Show) - -_NamespaceName = Core.Name "hydra.csharp.syntax.NamespaceName" - --- | A name that may refer to either a namespace or a type: identifier, qualified, or alias-qualified. -data NamespaceOrTypeName = - NamespaceOrTypeNameIdentifier IdentifierNamespaceOrTypeName | - NamespaceOrTypeNameQualified QualifiedNamespaceOrTypeName | - NamespaceOrTypeNameAlias QualifiedAliasMember - deriving (Eq, Ord, Read, Show) - -_NamespaceOrTypeName = Core.Name "hydra.csharp.syntax.NamespaceOrTypeName" - -_NamespaceOrTypeName_identifier = Core.Name "identifier" - -_NamespaceOrTypeName_qualified = Core.Name "qualified" - -_NamespaceOrTypeName_alias = Core.Name "alias" - --- | A type that is not itself an array type: value, class, interface, delegate, dynamic, or pointer. -data NonArrayType = - NonArrayTypeValue ValueType | - NonArrayTypeClass ClassType | - NonArrayTypeInterface InterfaceType | - NonArrayTypeDelegate DelegateType | - NonArrayTypeDynamic | - NonArrayTypeParameter TypeParameter | - NonArrayTypePointer PointerType - deriving (Eq, Ord, Read, Show) - -_NonArrayType = Core.Name "hydra.csharp.syntax.NonArrayType" - -_NonArrayType_value = Core.Name "value" - -_NonArrayType_class = Core.Name "class" - -_NonArrayType_interface = Core.Name "interface" - -_NonArrayType_delegate = Core.Name "delegate" - -_NonArrayType_dynamic = Core.Name "dynamic" - -_NonArrayType_parameter = Core.Name "parameter" - -_NonArrayType_pointer = Core.Name "pointer" - --- | Array creation giving the element type, dimension expressions, and rank specifiers directly. -data NonArrayTypeArrayCreationExpression = - NonArrayTypeArrayCreationExpression { - nonArrayTypeArrayCreationExpressionType :: NonArrayType, - nonArrayTypeArrayCreationExpressionExpressions :: ExpressionList, - nonArrayTypeArrayCreationExpressionRankSpecifiers :: [RankSpecifier], - nonArrayTypeArrayCreationExpressionInitializer :: (Maybe ArrayInitializer)} - deriving (Eq, Ord, Read, Show) - -_NonArrayTypeArrayCreationExpression = Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression" - -_NonArrayTypeArrayCreationExpression_type = Core.Name "type" - -_NonArrayTypeArrayCreationExpression_expressions = Core.Name "expressions" - -_NonArrayTypeArrayCreationExpression_rankSpecifiers = Core.Name "rankSpecifiers" - -_NonArrayTypeArrayCreationExpression_initializer = Core.Name "initializer" - --- | An expression other than an assignment: declaration, conditional, lambda, or query expression. -data NonAssignmentExpression = - NonAssignmentExpressionDeclaration DeclarationExpression | - NonAssignmentExpressionConditional ConditionalExpression | - NonAssignmentExpressionLambda LambdaExpression | - NonAssignmentExpressionQuery QueryExpression - deriving (Eq, Ord, Read, Show) - -_NonAssignmentExpression = Core.Name "hydra.csharp.syntax.NonAssignmentExpression" - -_NonAssignmentExpression_declaration = Core.Name "declaration" - -_NonAssignmentExpression_conditional = Core.Name "conditional" - -_NonAssignmentExpression_lambda = Core.Name "lambda" - -_NonAssignmentExpression_query = Core.Name "query" - --- | A simple, binary (??), or throw-expression form of the null-coalescing operator. -data NullCoalescingExpression = - NullCoalescingExpressionSimple ConditionalOrExpression | - NullCoalescingExpressionBinary BinaryNullCoalescingExpression | - NullCoalescingExpressionThrow NullCoalescingExpression - deriving (Eq, Ord, Read, Show) - -_NullCoalescingExpression = Core.Name "hydra.csharp.syntax.NullCoalescingExpression" - -_NullCoalescingExpression_simple = Core.Name "simple" - -_NullCoalescingExpression_binary = Core.Name "binary" - -_NullCoalescingExpression_throw = Core.Name "throw" - --- | A null-conditional element access (?[...]) with its chain of dependent accesses. -data NullConditionalElementAccess = - NullConditionalElementAccess { - nullConditionalElementAccessExpression :: PrimaryNoArrayCreationExpression, - nullConditionalElementAccessArguments :: ArgumentList, - nullConditionalElementAccessDependentAccess :: [DependentAccess]} - deriving (Eq, Ord, Read, Show) - -_NullConditionalElementAccess = Core.Name "hydra.csharp.syntax.NullConditionalElementAccess" - -_NullConditionalElementAccess_expression = Core.Name "expression" - -_NullConditionalElementAccess_arguments = Core.Name "arguments" - -_NullConditionalElementAccess_dependentAccess = Core.Name "dependentAccess" - --- | A null-conditional invocation (?.method(...) or ?[...]) with optional arguments. -data NullConditionalInvocationExpression = - NullConditionalInvocationExpression { - nullConditionalInvocationExpressionHead :: NullConditionalInvocationExpressionHead, - nullConditionalInvocationExpressionArguments :: (Maybe ArgumentList)} - deriving (Eq, Ord, Read, Show) - -_NullConditionalInvocationExpression = Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression" - -_NullConditionalInvocationExpression_head = Core.Name "head" - -_NullConditionalInvocationExpression_arguments = Core.Name "arguments" - --- | The member- or element-access head of a null-conditional invocation expression. -data NullConditionalInvocationExpressionHead = - NullConditionalInvocationExpressionHeadMember NullConditionalMemberAccess | - NullConditionalInvocationExpressionHeadElement NullConditionalElementAccess - deriving (Eq, Ord, Read, Show) - -_NullConditionalInvocationExpressionHead = Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpressionHead" - -_NullConditionalInvocationExpressionHead_member = Core.Name "member" - -_NullConditionalInvocationExpressionHead_element = Core.Name "element" - --- | A null-conditional member access (?.member) with its chain of dependent accesses. -data NullConditionalMemberAccess = - NullConditionalMemberAccess { - nullConditionalMemberAccessExpression :: PrimaryExpression, - nullConditionalMemberAccessIdentifier :: Identifier, - nullConditionalMemberAccessTypeArguments :: (Maybe TypeArgumentList), - nullConditionalMemberAccessDependentAccess :: [DependentAccess]} - deriving (Eq, Ord, Read, Show) - -_NullConditionalMemberAccess = Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess" - -_NullConditionalMemberAccess_expression = Core.Name "expression" - -_NullConditionalMemberAccess_identifier = Core.Name "identifier" - -_NullConditionalMemberAccess_typeArguments = Core.Name "typeArguments" - -_NullConditionalMemberAccess_dependentAccess = Core.Name "dependentAccess" - --- | A null-conditional member projection used inside an anonymous object initializer. -data NullConditionalProjectionInitializer = - NullConditionalProjectionInitializer { - nullConditionalProjectionInitializerExpression :: PrimaryExpression, - nullConditionalProjectionInitializerIdentifier :: Identifier, - nullConditionalProjectionInitializerTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_NullConditionalProjectionInitializer = Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer" - -_NullConditionalProjectionInitializer_expression = Core.Name "expression" - -_NullConditionalProjectionInitializer_identifier = Core.Name "identifier" - -_NullConditionalProjectionInitializer_typeArguments = Core.Name "typeArguments" - --- | A numeric type: integral, floating-point, or decimal. -data NumericType = - NumericTypeIntegral IntegralType | - NumericTypeFloatingPoint FloatingPointType | - NumericTypeDecimal - deriving (Eq, Ord, Read, Show) - -_NumericType = Core.Name "hydra.csharp.syntax.NumericType" - -_NumericType_integral = Core.Name "integral" - -_NumericType_floatingPoint = Core.Name "floatingPoint" - -_NumericType_decimal = Core.Name "decimal" - --- | A 'new' expression that constructs an object, with optional arguments and initializer. -data ObjectCreationExpression = - ObjectCreationExpression { - objectCreationExpressionType :: Type, - objectCreationExpressionArguments :: (Maybe ArgumentList), - objectCreationExpressionInitializer :: (Maybe ObjectOrCollectionInitializer)} - deriving (Eq, Ord, Read, Show) - -_ObjectCreationExpression = Core.Name "hydra.csharp.syntax.ObjectCreationExpression" - -_ObjectCreationExpression_type = Core.Name "type" - -_ObjectCreationExpression_arguments = Core.Name "arguments" - -_ObjectCreationExpression_initializer = Core.Name "initializer" - --- | An object initializer's member list, or a collection initializer's element list. -data ObjectOrCollectionInitializer = - ObjectOrCollectionInitializerObject [MemberInitializer] | - ObjectOrCollectionInitializerCollection [ElementInitializer] - deriving (Eq, Ord, Read, Show) - -_ObjectOrCollectionInitializer = Core.Name "hydra.csharp.syntax.ObjectOrCollectionInitializer" - -_ObjectOrCollectionInitializer_object = Core.Name "object" - -_ObjectOrCollectionInitializer_collection = Core.Name "collection" - --- | The body of an operator overload declaration: a block, expression body, or empty (extern) body. -data OperatorBody = - OperatorBodyBlock Block | - OperatorBodyExpression Expression | - OperatorBodyEmpty - deriving (Eq, Ord, Read, Show) - -_OperatorBody = Core.Name "hydra.csharp.syntax.OperatorBody" - -_OperatorBody_block = Core.Name "block" - -_OperatorBody_expression = Core.Name "expression" - -_OperatorBody_empty = Core.Name "empty" - --- | A user-defined operator overload declaration, with its modifiers, declarator, and body. -data OperatorDeclaration = - OperatorDeclaration { - operatorDeclarationAttributes :: (Maybe Attributes), - operatorDeclarationModifiers :: [OperatorModifier], - operatorDeclarationDeclarator :: OperatorDeclarator, - operatorDeclarationBody :: OperatorBody} - deriving (Eq, Ord, Read, Show) - -_OperatorDeclaration = Core.Name "hydra.csharp.syntax.OperatorDeclaration" - -_OperatorDeclaration_attributes = Core.Name "attributes" - -_OperatorDeclaration_modifiers = Core.Name "modifiers" - -_OperatorDeclaration_declarator = Core.Name "declarator" - -_OperatorDeclaration_body = Core.Name "body" - --- | The declarator of an operator overload: unary, binary, or conversion form. -data OperatorDeclarator = - OperatorDeclaratorUnary UnaryOperatorDeclarator | - OperatorDeclaratorBinary BinaryOperatorDeclarator | - OperatorDeclaratorConversion ConversionOperatorDeclarator - deriving (Eq, Ord, Read, Show) - -_OperatorDeclarator = Core.Name "hydra.csharp.syntax.OperatorDeclarator" - -_OperatorDeclarator_unary = Core.Name "unary" - -_OperatorDeclarator_binary = Core.Name "binary" - -_OperatorDeclarator_conversion = Core.Name "conversion" - --- | A modifier keyword on an operator declaration: public, static, extern, or unsafe. -data OperatorModifier = - OperatorModifierPublic | - OperatorModifierStatic | - OperatorModifierExtern | - OperatorModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_OperatorModifier = Core.Name "hydra.csharp.syntax.OperatorModifier" - -_OperatorModifier_public = Core.Name "public" - -_OperatorModifier_static = Core.Name "static" - -_OperatorModifier_extern = Core.Name "extern" - -_OperatorModifier_unsafe = Core.Name "unsafe" - --- | A single ordering key expression, with an optional ascending/descending direction, in an orderby clause. -data Ordering = - Ordering { - orderingExpression :: Expression, - orderingDirection :: (Maybe OrderingDirection)} - deriving (Eq, Ord, Read, Show) - -_Ordering = Core.Name "hydra.csharp.syntax.Ordering" - -_Ordering_expression = Core.Name "expression" - -_Ordering_direction = Core.Name "direction" - --- | The ascending or descending direction of an ordering key in an orderby clause. -data OrderingDirection = - OrderingDirectionAscending | - OrderingDirectionDescending - deriving (Eq, Ord, Read, Show) - -_OrderingDirection = Core.Name "hydra.csharp.syntax.OrderingDirection" - -_OrderingDirection_ascending = Core.Name "ascending" - -_OrderingDirection_descending = Core.Name "descending" - --- | A binary operator symbol that may be overloaded via a user-defined operator declaration. -data OverloadableBinaryOperator = - OverloadableBinaryOperatorAdd | - OverloadableBinaryOperatorSubtract | - OverloadableBinaryOperatorMultiply | - OverloadableBinaryOperatorDivide | - OverloadableBinaryOperatorModulus | - OverloadableBinaryOperatorAnd | - OverloadableBinaryOperatorOr | - OverloadableBinaryOperatorXor | - OverloadableBinaryOperatorLeftShift | - OverloadableBinaryOperatorRightShift | - OverloadableBinaryOperatorEqual | - OverloadableBinaryOperatorNotEqual | - OverloadableBinaryOperatorGreaterThan | - OverloadableBinaryOperatorLessThan | - OverloadableBinaryOperatorGreaterThanOrEqual | - OverloadableBinaryOperatorLessThanOrEqual - deriving (Eq, Ord, Read, Show) - -_OverloadableBinaryOperator = Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator" - -_OverloadableBinaryOperator_add = Core.Name "add" - -_OverloadableBinaryOperator_subtract = Core.Name "subtract" - -_OverloadableBinaryOperator_multiply = Core.Name "multiply" - -_OverloadableBinaryOperator_divide = Core.Name "divide" - -_OverloadableBinaryOperator_modulus = Core.Name "modulus" - -_OverloadableBinaryOperator_and = Core.Name "and" - -_OverloadableBinaryOperator_or = Core.Name "or" - -_OverloadableBinaryOperator_xor = Core.Name "xor" - -_OverloadableBinaryOperator_leftShift = Core.Name "leftShift" - -_OverloadableBinaryOperator_rightShift = Core.Name "rightShift" - -_OverloadableBinaryOperator_equal = Core.Name "equal" - -_OverloadableBinaryOperator_notEqual = Core.Name "notEqual" - -_OverloadableBinaryOperator_greaterThan = Core.Name "greaterThan" - -_OverloadableBinaryOperator_lessThan = Core.Name "lessThan" - -_OverloadableBinaryOperator_greaterThanOrEqual = Core.Name "greaterThanOrEqual" - -_OverloadableBinaryOperator_lessThanOrEqual = Core.Name "lessThanOrEqual" - --- | A unary operator symbol that may be overloaded via a user-defined operator declaration. -data OverloadableUnaryOperator = - OverloadableUnaryOperatorPlus | - OverloadableUnaryOperatorMinus | - OverloadableUnaryOperatorNot | - OverloadableUnaryOperatorComplement | - OverloadableUnaryOperatorIncrement | - OverloadableUnaryOperatorDecrement | - OverloadableUnaryOperatorTrue | - OverloadableUnaryOperatorFalse - deriving (Eq, Ord, Read, Show) - -_OverloadableUnaryOperator = Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator" - -_OverloadableUnaryOperator_plus = Core.Name "plus" - -_OverloadableUnaryOperator_minus = Core.Name "minus" - -_OverloadableUnaryOperator_not = Core.Name "not" - -_OverloadableUnaryOperator_complement = Core.Name "complement" - -_OverloadableUnaryOperator_increment = Core.Name "increment" - -_OverloadableUnaryOperator_decrement = Core.Name "decrement" - -_OverloadableUnaryOperator_true = Core.Name "true" - -_OverloadableUnaryOperator_false = Core.Name "false" - --- | A trailing 'params' array parameter of a formal parameter list. -data ParameterArray = - ParameterArray { - parameterArrayAttributes :: (Maybe Attributes), - parameterArrayType :: ArrayType, - parameterArrayIdentifier :: Identifier} - deriving (Eq, Ord, Read, Show) - -_ParameterArray = Core.Name "hydra.csharp.syntax.ParameterArray" - -_ParameterArray_attributes = Core.Name "attributes" - -_ParameterArray_type = Core.Name "type" - -_ParameterArray_identifier = Core.Name "identifier" - --- | The ref, out, or in passing-mode modifier on a fixed parameter. -data ParameterModeModifier = - ParameterModeModifierRef | - ParameterModeModifierOut | - ParameterModeModifierIn - deriving (Eq, Ord, Read, Show) - -_ParameterModeModifier = Core.Name "hydra.csharp.syntax.ParameterModeModifier" - -_ParameterModeModifier_ref = Core.Name "ref" - -_ParameterModeModifier_out = Core.Name "out" - -_ParameterModeModifier_in = Core.Name "in" - --- | A modifier on a fixed parameter: a passing-mode modifier, or 'this' for extension methods. -data ParameterModifier = - ParameterModifierMode ParameterModeModifier | - ParameterModifierThis - deriving (Eq, Ord, Read, Show) - -_ParameterModifier = Core.Name "hydra.csharp.syntax.ParameterModifier" - -_ParameterModifier_mode = Core.Name "mode" - -_ParameterModifier_this = Core.Name "this" - --- | A pattern used in pattern matching: a declaration, constant, or var pattern. -data Pattern = - PatternDeclaration DeclarationPattern | - PatternConstant Expression | - PatternVar Designation - deriving (Eq, Ord, Read, Show) - -_Pattern = Core.Name "hydra.csharp.syntax.Pattern" - -_Pattern_declaration = Core.Name "declaration" - -_Pattern_constant = Core.Name "constant" - -_Pattern_var = Core.Name "var" - --- | An unsafe pointer indexing expression (pointer[index]). -data PointerElementAccess = - PointerElementAccess { - pointerElementAccessPointer :: PrimaryNoArrayCreationExpression, - pointerElementAccessIndex :: Expression} - deriving (Eq, Ord, Read, Show) - -_PointerElementAccess = Core.Name "hydra.csharp.syntax.PointerElementAccess" - -_PointerElementAccess_pointer = Core.Name "pointer" - -_PointerElementAccess_index = Core.Name "index" - --- | An unsafe pointer member access expression (pointer->member). -data PointerMemberAccess = - PointerMemberAccess { - pointerMemberAccessPointer :: PrimaryExpression, - pointerMemberAccessMember :: Identifier, - pointerMemberAccessTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_PointerMemberAccess = Core.Name "hydra.csharp.syntax.PointerMemberAccess" - -_PointerMemberAccess_pointer = Core.Name "pointer" - -_PointerMemberAccess_member = Core.Name "member" - -_PointerMemberAccess_typeArguments = Core.Name "typeArguments" - --- | An unsafe pointer type, formed from a pointee value type and a pointer depth. -data PointerType = - PointerTypeValueType (Maybe ValueType) | - PointerTypePointerDepth Int - deriving (Eq, Ord, Read, Show) - -_PointerType = Core.Name "hydra.csharp.syntax.PointerType" - -_PointerType_valueType = Core.Name "valueType" - -_PointerType_pointerDepth = Core.Name "pointerDepth" - --- | A single positional (or optionally named) argument in an attribute's argument list. -data PositionalArgument = - PositionalArgument { - positionalArgumentName :: (Maybe Identifier), - positionalArgumentValue :: AttributeArgumentExpression} - deriving (Eq, Ord, Read, Show) - -_PositionalArgument = Core.Name "hydra.csharp.syntax.PositionalArgument" - -_PositionalArgument_name = Core.Name "name" - -_PositionalArgument_value = Core.Name "value" - --- | A non-empty, comma-separated list of positional arguments passed to an attribute. -newtype PositionalArgumentList = - PositionalArgumentList { - unPositionalArgumentList :: [PositionalArgument]} - deriving (Eq, Ord, Read, Show) - -_PositionalArgumentList = Core.Name "hydra.csharp.syntax.PositionalArgumentList" - --- | One of the built-in predefined type keywords, such as int, string, or bool. -data PredefinedType = - PredefinedTypeBool | - PredefinedTypeByte | - PredefinedTypeChar | - PredefinedTypeDecimal | - PredefinedTypeDouble | - PredefinedTypeFloat | - PredefinedTypeInt | - PredefinedTypeLong | - PredefinedTypeObject | - PredefinedTypeSbyte | - PredefinedTypeShort | - PredefinedTypeString | - PredefinedTypeUint | - PredefinedTypeUlong | - PredefinedTypeUshort - deriving (Eq, Ord, Read, Show) - -_PredefinedType = Core.Name "hydra.csharp.syntax.PredefinedType" - -_PredefinedType_bool = Core.Name "bool" - -_PredefinedType_byte = Core.Name "byte" - -_PredefinedType_char = Core.Name "char" - -_PredefinedType_decimal = Core.Name "decimal" - -_PredefinedType_double = Core.Name "double" - -_PredefinedType_float = Core.Name "float" - -_PredefinedType_int = Core.Name "int" - -_PredefinedType_long = Core.Name "long" - -_PredefinedType_object = Core.Name "object" - -_PredefinedType_sbyte = Core.Name "sbyte" - -_PredefinedType_short = Core.Name "short" - -_PredefinedType_string = Core.Name "string" - -_PredefinedType_uint = Core.Name "uint" - -_PredefinedType_ulong = Core.Name "ulong" - -_PredefinedType_ushort = Core.Name "ushort" - --- | The primary type-parameter constraint: a class type, or the class/struct/unmanaged constraint. -data PrimaryConstraint = - PrimaryConstraintClassType ClassType | - PrimaryConstraintClass | - PrimaryConstraintStruct | - PrimaryConstraintUnmanaged - deriving (Eq, Ord, Read, Show) - -_PrimaryConstraint = Core.Name "hydra.csharp.syntax.PrimaryConstraint" - -_PrimaryConstraint_classType = Core.Name "classType" - -_PrimaryConstraint_class = Core.Name "class" - -_PrimaryConstraint_struct = Core.Name "struct" - -_PrimaryConstraint_unmanaged = Core.Name "unmanaged" - --- | An expression without an array creation, or an array creation expression. -data PrimaryExpression = - PrimaryExpressionNoArray PrimaryNoArrayCreationExpression | - PrimaryExpressionArray ArrayCreationExpression - deriving (Eq, Ord, Read, Show) - -_PrimaryExpression = Core.Name "hydra.csharp.syntax.PrimaryExpression" - -_PrimaryExpression_noArray = Core.Name "noArray" - -_PrimaryExpression_array = Core.Name "array" - --- | A primary expression other than array creation: literal, invocation, access, and so on. -data PrimaryNoArrayCreationExpression = - PrimaryNoArrayCreationExpressionLiteral Literal | - PrimaryNoArrayCreationExpressionInterpolatedString InterpolatedStringExpression | - PrimaryNoArrayCreationExpressionSimpleName SimpleName | - PrimaryNoArrayCreationExpressionParenthesized Expression | - PrimaryNoArrayCreationExpressionTuple TupleExpression | - PrimaryNoArrayCreationExpressionMemberAccess MemberAccess | - PrimaryNoArrayCreationExpressionNullConditionalMemberAccess NullConditionalMemberAccess | - PrimaryNoArrayCreationExpressionInvocation InvocationExpression | - PrimaryNoArrayCreationExpressionElementAccess ElementAccess | - PrimaryNoArrayCreationExpressionNullConditionalElementAccess NullConditionalElementAccess | - PrimaryNoArrayCreationExpressionThisAccess | - PrimaryNoArrayCreationExpressionBaseAccess BaseAccess | - PrimaryNoArrayCreationExpressionPostIncrement PrimaryExpression | - PrimaryNoArrayCreationExpressionPostDecrement PrimaryExpression | - PrimaryNoArrayCreationExpressionObjectCreation ObjectCreationExpression | - PrimaryNoArrayCreationExpressionDelegateCreation DelegateCreationExpression | - PrimaryNoArrayCreationExpressionAnonymousObjectCreation (Maybe MemberDeclaratorList) | - PrimaryNoArrayCreationExpressionTypeof TypeofExpression | - PrimaryNoArrayCreationExpressionSizeof UnmanagedType | - PrimaryNoArrayCreationExpressionChecked Expression | - PrimaryNoArrayCreationExpressionUnchecked Expression | - PrimaryNoArrayCreationExpressionDefaultValue DefaultValueExpression | - PrimaryNoArrayCreationExpressionNameof NamedEntity | - PrimaryNoArrayCreationExpressionAnonymousMethod AnonymousMethodExpression | - PrimaryNoArrayCreationExpressionPointerMemberAccess PointerMemberAccess | - PrimaryNoArrayCreationExpressionPointerElementAccess PointerElementAccess | - PrimaryNoArrayCreationExpressionStackalloc StackallocExpression - deriving (Eq, Ord, Read, Show) - -_PrimaryNoArrayCreationExpression = Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression" - -_PrimaryNoArrayCreationExpression_literal = Core.Name "literal" - -_PrimaryNoArrayCreationExpression_interpolatedString = Core.Name "interpolatedString" - -_PrimaryNoArrayCreationExpression_simpleName = Core.Name "simpleName" - -_PrimaryNoArrayCreationExpression_parenthesized = Core.Name "parenthesized" - -_PrimaryNoArrayCreationExpression_tuple = Core.Name "tuple" - -_PrimaryNoArrayCreationExpression_memberAccess = Core.Name "memberAccess" - -_PrimaryNoArrayCreationExpression_nullConditionalMemberAccess = Core.Name "nullConditionalMemberAccess" - -_PrimaryNoArrayCreationExpression_invocation = Core.Name "invocation" - -_PrimaryNoArrayCreationExpression_elementAccess = Core.Name "elementAccess" - -_PrimaryNoArrayCreationExpression_nullConditionalElementAccess = Core.Name "nullConditionalElementAccess" - -_PrimaryNoArrayCreationExpression_thisAccess = Core.Name "thisAccess" - -_PrimaryNoArrayCreationExpression_baseAccess = Core.Name "baseAccess" - -_PrimaryNoArrayCreationExpression_postIncrement = Core.Name "postIncrement" - -_PrimaryNoArrayCreationExpression_postDecrement = Core.Name "postDecrement" - -_PrimaryNoArrayCreationExpression_objectCreation = Core.Name "objectCreation" - -_PrimaryNoArrayCreationExpression_delegateCreation = Core.Name "delegateCreation" - -_PrimaryNoArrayCreationExpression_anonymousObjectCreation = Core.Name "anonymousObjectCreation" - -_PrimaryNoArrayCreationExpression_typeof = Core.Name "typeof" - -_PrimaryNoArrayCreationExpression_sizeof = Core.Name "sizeof" - -_PrimaryNoArrayCreationExpression_checked = Core.Name "checked" - -_PrimaryNoArrayCreationExpression_unchecked = Core.Name "unchecked" - -_PrimaryNoArrayCreationExpression_defaultValue = Core.Name "defaultValue" - -_PrimaryNoArrayCreationExpression_nameof = Core.Name "nameof" - -_PrimaryNoArrayCreationExpression_anonymousMethod = Core.Name "anonymousMethod" - -_PrimaryNoArrayCreationExpression_pointerMemberAccess = Core.Name "pointerMemberAccess" - -_PrimaryNoArrayCreationExpression_pointerElementAccess = Core.Name "pointerElementAccess" - -_PrimaryNoArrayCreationExpression_stackalloc = Core.Name "stackalloc" - --- | The body of a standard property: block accessors or a single expression body. -data PropertyBody = - PropertyBodyBlock BlockPropertyBody | - PropertyBodyExpression Expression - deriving (Eq, Ord, Read, Show) - -_PropertyBody = Core.Name "hydra.csharp.syntax.PropertyBody" - -_PropertyBody_block = Core.Name "block" - -_PropertyBody_expression = Core.Name "expression" - --- | A property member declaration, in its standard or ref-returning form. -data PropertyDeclaration = - PropertyDeclarationStandard StandardPropertyDeclaration | - PropertyDeclarationRefReturn RefReturnPropertyDeclaration - deriving (Eq, Ord, Read, Show) - -_PropertyDeclaration = Core.Name "hydra.csharp.syntax.PropertyDeclaration" - -_PropertyDeclaration_standard = Core.Name "standard" - -_PropertyDeclaration_refReturn = Core.Name "refReturn" - --- | A modifier keyword on a property declaration, such as virtual, override, or abstract. -data PropertyModifier = - PropertyModifierNew | - PropertyModifierPublic | - PropertyModifierProtected | - PropertyModifierInternal | - PropertyModifierPrivate | - PropertyModifierStatic | - PropertyModifierVirtual | - PropertyModifierSealed | - PropertyModifierOverride | - PropertyModifierAbstract | - PropertyModifierExtern | - PropertyModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_PropertyModifier = Core.Name "hydra.csharp.syntax.PropertyModifier" - -_PropertyModifier_new = Core.Name "new" - -_PropertyModifier_public = Core.Name "public" - -_PropertyModifier_protected = Core.Name "protected" - -_PropertyModifier_internal = Core.Name "internal" - -_PropertyModifier_private = Core.Name "private" - -_PropertyModifier_static = Core.Name "static" - -_PropertyModifier_virtual = Core.Name "virtual" - -_PropertyModifier_sealed = Core.Name "sealed" - -_PropertyModifier_override = Core.Name "override" - -_PropertyModifier_abstract = Core.Name "abstract" - -_PropertyModifier_extern = Core.Name "extern" - -_PropertyModifier_unsafe = Core.Name "unsafe" - --- | An 'alias::member' reference, with optional type arguments, using an extern or global alias. -data QualifiedAliasMember = - QualifiedAliasMember { - qualifiedAliasMemberAlias :: Identifier, - qualifiedAliasMemberMember :: Identifier, - qualifiedAliasMemberArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_QualifiedAliasMember = Core.Name "hydra.csharp.syntax.QualifiedAliasMember" - -_QualifiedAliasMember_alias = Core.Name "alias" - -_QualifiedAliasMember_member = Core.Name "member" - -_QualifiedAliasMember_arguments = Core.Name "arguments" - --- | A non-empty, dot-separated sequence of identifiers, as used in a namespace declaration. -newtype QualifiedIdentifier = - QualifiedIdentifier { - unQualifiedIdentifier :: [Identifier]} - deriving (Eq, Ord, Read, Show) - -_QualifiedIdentifier = Core.Name "hydra.csharp.syntax.QualifiedIdentifier" - --- | A namespace-or-type name qualified with a preceding namespace-or-type and identifier. -data QualifiedNamespaceOrTypeName = - QualifiedNamespaceOrTypeName { - qualifiedNamespaceOrTypeNameNamespaceOrType :: NamespaceOrTypeName, - qualifiedNamespaceOrTypeNameIdentifier :: Identifier, - qualifiedNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_QualifiedNamespaceOrTypeName = Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName" - -_QualifiedNamespaceOrTypeName_namespaceOrType = Core.Name "namespaceOrType" - -_QualifiedNamespaceOrTypeName_identifier = Core.Name "identifier" - -_QualifiedNamespaceOrTypeName_arguments = Core.Name "arguments" - --- | The clauses, select/group clause, and optional continuation of a query expression. -data QueryBody = - QueryBody { - queryBodyClauses :: [QueryBodyClause], - queryBodySelectOrGroup :: SelectOrGroupClause, - queryBodyContinuation :: (Maybe QueryContinuation)} - deriving (Eq, Ord, Read, Show) - -_QueryBody = Core.Name "hydra.csharp.syntax.QueryBody" - -_QueryBody_clauses = Core.Name "clauses" - -_QueryBody_selectOrGroup = Core.Name "selectOrGroup" - -_QueryBody_continuation = Core.Name "continuation" - --- | A clause in a query expression body: from, let, where, join, or orderby. -data QueryBodyClause = - QueryBodyClauseFrom FromClause | - QueryBodyClauseLet LetClause | - QueryBodyClauseWhere BooleanExpression | - QueryBodyClauseJoin JoinClause | - QueryBodyClauseOrderby [Ordering] - deriving (Eq, Ord, Read, Show) - -_QueryBodyClause = Core.Name "hydra.csharp.syntax.QueryBodyClause" - -_QueryBodyClause_from = Core.Name "from" - -_QueryBodyClause_let = Core.Name "let" - -_QueryBodyClause_where = Core.Name "where" - -_QueryBodyClause_join = Core.Name "join" - -_QueryBodyClause_orderby = Core.Name "orderby" - --- | An 'into' continuation that feeds a query's results into a further query body. -data QueryContinuation = - QueryContinuation { - queryContinuationInto :: Identifier, - queryContinuationBody :: QueryBody} - deriving (Eq, Ord, Read, Show) - -_QueryContinuation = Core.Name "hydra.csharp.syntax.QueryContinuation" - -_QueryContinuation_into = Core.Name "into" - -_QueryContinuation_body = Core.Name "body" - --- | A LINQ query expression, starting with a from clause and continuing with a query body. -data QueryExpression = - QueryExpression { - queryExpressionFrom :: FromClause, - queryExpressionBody :: QueryBody} - deriving (Eq, Ord, Read, Show) - -_QueryExpression = Core.Name "hydra.csharp.syntax.QueryExpression" - -_QueryExpression_from = Core.Name "from" - -_QueryExpression_body = Core.Name "body" - --- | The rank (number of dimensions) of an array type or array creation expression. -newtype RankSpecifier = - RankSpecifier { - unRankSpecifier :: Int} - deriving (Eq, Ord, Read, Show) - -_RankSpecifier = Core.Name "hydra.csharp.syntax.RankSpecifier" - --- | Array creation using a rank specifier together with an array initializer, with inferred element type. -data RankSpecifierArrayCreationExpression = - RankSpecifierArrayCreationExpression { - rankSpecifierArrayCreationExpressionRankSpecifier :: RankSpecifier, - rankSpecifierArrayCreationExpressionInitializer :: ArrayInitializer} - deriving (Eq, Ord, Read, Show) - -_RankSpecifierArrayCreationExpression = Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression" - -_RankSpecifierArrayCreationExpression_rankSpecifier = Core.Name "rankSpecifier" - -_RankSpecifierArrayCreationExpression_initializer = Core.Name "initializer" - --- | The body of a ref-returning get accessor: a block, ref expression, or empty (abstract) body. -data RefAccessorBody = - RefAccessorBodyBlock Block | - RefAccessorBodyRef VariableReference | - RefAccessorBodyEmpty - deriving (Eq, Ord, Read, Show) - -_RefAccessorBody = Core.Name "hydra.csharp.syntax.RefAccessorBody" - -_RefAccessorBody_block = Core.Name "block" - -_RefAccessorBody_ref = Core.Name "ref" - -_RefAccessorBody_empty = Core.Name "empty" - --- | A ref-returning conditional expression, selecting between two variable references. -data RefConditionalExpression = - RefConditionalExpression { - refConditionalExpressionCondition :: NullCoalescingExpression, - refConditionalExpressionTrue :: VariableReference, - refConditionalExpressionFalse :: VariableReference} - deriving (Eq, Ord, Read, Show) - -_RefConditionalExpression = Core.Name "hydra.csharp.syntax.RefConditionalExpression" - -_RefConditionalExpression_condition = Core.Name "condition" - -_RefConditionalExpression_true = Core.Name "true" - -_RefConditionalExpression_false = Core.Name "false" - --- | A ref-returning property or indexer get accessor declaration. -data RefGetAccessorDeclaration = - RefGetAccessorDeclaration { - refGetAccessorDeclarationAttributes :: (Maybe Attributes), - refGetAccessorDeclarationModifier :: (Maybe AccessorModifier), - refGetAccessorDeclarationBody :: RefAccessorBody} - deriving (Eq, Ord, Read, Show) - -_RefGetAccessorDeclaration = Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration" - -_RefGetAccessorDeclaration_attributes = Core.Name "attributes" - -_RefGetAccessorDeclaration_modifier = Core.Name "modifier" - -_RefGetAccessorDeclaration_body = Core.Name "body" - --- | The body of a ref-returning indexer: a ref get accessor, or a single ref expression. -data RefIndexerBody = - RefIndexerBodyBlock RefGetAccessorDeclaration | - RefIndexerBodyRef VariableReference - deriving (Eq, Ord, Read, Show) - -_RefIndexerBody = Core.Name "hydra.csharp.syntax.RefIndexerBody" - -_RefIndexerBody_block = Core.Name "block" - -_RefIndexerBody_ref = Core.Name "ref" - --- | A ref-returning indexer member declaration. -data RefIndexerDeclaration = - RefIndexerDeclaration { - refIndexerDeclarationAttributes :: (Maybe Attributes), - refIndexerDeclarationModifiers :: [IndexerModifier], - refIndexerDeclarationRefKind :: RefKind, - refIndexerDeclarationDeclarator :: IndexerDeclarator, - refIndexerDeclarationBody :: RefIndexerBody} - deriving (Eq, Ord, Read, Show) - -_RefIndexerDeclaration = Core.Name "hydra.csharp.syntax.RefIndexerDeclaration" - -_RefIndexerDeclaration_attributes = Core.Name "attributes" - -_RefIndexerDeclaration_modifiers = Core.Name "modifiers" - -_RefIndexerDeclaration_refKind = Core.Name "refKind" - -_RefIndexerDeclaration_declarator = Core.Name "declarator" - -_RefIndexerDeclaration_body = Core.Name "body" - --- | Whether a ref-returning member returns by plain ref or by ref readonly. -data RefKind = - RefKindRef | - RefKindRefReadonly - deriving (Eq, Ord, Read, Show) - -_RefKind = Core.Name "hydra.csharp.syntax.RefKind" - -_RefKind_ref = Core.Name "ref" - -_RefKind_refReadonly = Core.Name "refReadonly" - --- | The body of a ref-returning local function: a block, or a single ref expression. -data RefLocalFunctionBody = - RefLocalFunctionBodyBlock Block | - RefLocalFunctionBodyRef VariableReference - deriving (Eq, Ord, Read, Show) - -_RefLocalFunctionBody = Core.Name "hydra.csharp.syntax.RefLocalFunctionBody" - -_RefLocalFunctionBody_block = Core.Name "block" - -_RefLocalFunctionBody_ref = Core.Name "ref" - --- | A ref-returning local function declaration. -data RefLocalFunctionDeclaration = - RefLocalFunctionDeclaration { - refLocalFunctionDeclarationModifiers :: [RefLocalFunctionModifier], - refLocalFunctionDeclarationRefKind :: RefKind, - refLocalFunctionDeclarationReturnType :: Type, - refLocalFunctionDeclarationHeader :: LocalFunctionHeader, - refLocalFunctionDeclarationBody :: RefLocalFunctionBody} - deriving (Eq, Ord, Read, Show) - -_RefLocalFunctionDeclaration = Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration" - -_RefLocalFunctionDeclaration_modifiers = Core.Name "modifiers" - -_RefLocalFunctionDeclaration_refKind = Core.Name "refKind" - -_RefLocalFunctionDeclaration_returnType = Core.Name "returnType" - -_RefLocalFunctionDeclaration_header = Core.Name "header" - -_RefLocalFunctionDeclaration_body = Core.Name "body" - --- | A modifier on a ref-returning local function declaration: static or unsafe. -data RefLocalFunctionModifier = - RefLocalFunctionModifierStatic | - RefLocalFunctionModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_RefLocalFunctionModifier = Core.Name "hydra.csharp.syntax.RefLocalFunctionModifier" - -_RefLocalFunctionModifier_static = Core.Name "static" - -_RefLocalFunctionModifier_unsafe = Core.Name "unsafe" - --- | A local variable declaration that binds a variable by reference. -data RefLocalVariableDeclaration = - RefLocalVariableDeclaration { - refLocalVariableDeclarationRefKind :: RefKind, - refLocalVariableDeclarationType :: Type, - refLocalVariableDeclarationDeclarators :: [RefLocalVariableDeclarator]} - deriving (Eq, Ord, Read, Show) - -_RefLocalVariableDeclaration = Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration" - -_RefLocalVariableDeclaration_refKind = Core.Name "refKind" - -_RefLocalVariableDeclaration_type = Core.Name "type" - -_RefLocalVariableDeclaration_declarators = Core.Name "declarators" - --- | The identifier and referenced variable in a single ref local variable declarator. -data RefLocalVariableDeclarator = - RefLocalVariableDeclarator { - refLocalVariableDeclaratorLeft :: Identifier, - refLocalVariableDeclaratorRight :: VariableReference} - deriving (Eq, Ord, Read, Show) - -_RefLocalVariableDeclarator = Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator" - -_RefLocalVariableDeclarator_left = Core.Name "left" - -_RefLocalVariableDeclarator_right = Core.Name "right" - --- | The body of a ref-returning method: a block, ref expression, or empty (extern) body. -data RefMethodBody = - RefMethodBodyBlock Block | - RefMethodBodyRef VariableReference | - RefMethodBodyEmpty - deriving (Eq, Ord, Read, Show) - -_RefMethodBody = Core.Name "hydra.csharp.syntax.RefMethodBody" - -_RefMethodBody_block = Core.Name "block" - -_RefMethodBody_ref = Core.Name "ref" - -_RefMethodBody_empty = Core.Name "empty" - --- | A modifier keyword on a ref-returning method declaration. -data RefMethodModifier = - RefMethodModifierNew | - RefMethodModifierPublic | - RefMethodModifierProtected | - RefMethodModifierInternal | - RefMethodModifierPrivate | - RefMethodModifierStatic | - RefMethodModifierVirtual | - RefMethodModifierSealed | - RefMethodModifierOverride | - RefMethodModifierAbstract | - RefMethodModifierExtern | - RefMethodModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_RefMethodModifier = Core.Name "hydra.csharp.syntax.RefMethodModifier" - -_RefMethodModifier_new = Core.Name "new" - -_RefMethodModifier_public = Core.Name "public" - -_RefMethodModifier_protected = Core.Name "protected" - -_RefMethodModifier_internal = Core.Name "internal" - -_RefMethodModifier_private = Core.Name "private" - -_RefMethodModifier_static = Core.Name "static" - -_RefMethodModifier_virtual = Core.Name "virtual" - -_RefMethodModifier_sealed = Core.Name "sealed" - -_RefMethodModifier_override = Core.Name "override" - -_RefMethodModifier_abstract = Core.Name "abstract" - -_RefMethodModifier_extern = Core.Name "extern" - -_RefMethodModifier_unsafe = Core.Name "unsafe" - --- | The body of a ref-returning property: a ref get accessor, or a single ref expression. -data RefPropertyBody = - RefPropertyBodyBlock RefGetAccessorDeclaration | - RefPropertyBodyRef VariableReference - deriving (Eq, Ord, Read, Show) - -_RefPropertyBody = Core.Name "hydra.csharp.syntax.RefPropertyBody" - -_RefPropertyBody_block = Core.Name "block" - -_RefPropertyBody_ref = Core.Name "ref" - --- | A ref-returning method declaration, including its ref kind, header, and body. -data RefReturnMethodDeclaration = - RefReturnMethodDeclaration { - refReturnMethodDeclarationAttributes :: (Maybe Attributes), - refReturnMethodDeclarationModifiers :: [RefMethodModifier], - refReturnMethodDeclarationKind :: RefKind, - refReturnMethodDeclarationReturnType :: ReturnType, - refReturnMethodDeclarationHeader :: MethodHeader, - refReturnMethodDeclarationBody :: RefMethodBody} - deriving (Eq, Ord, Read, Show) - -_RefReturnMethodDeclaration = Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration" - -_RefReturnMethodDeclaration_attributes = Core.Name "attributes" - -_RefReturnMethodDeclaration_modifiers = Core.Name "modifiers" - -_RefReturnMethodDeclaration_kind = Core.Name "kind" - -_RefReturnMethodDeclaration_returnType = Core.Name "returnType" - -_RefReturnMethodDeclaration_header = Core.Name "header" - -_RefReturnMethodDeclaration_body = Core.Name "body" - --- | A ref-returning property declaration, including its ref kind and body. -data RefReturnPropertyDeclaration = - RefReturnPropertyDeclaration { - refReturnPropertyDeclarationAttributes :: (Maybe Attributes), - refReturnPropertyDeclarationModifiers :: [PropertyModifier], - refReturnPropertyDeclarationRefKind :: RefKind, - refReturnPropertyDeclarationType :: Type, - refReturnPropertyDeclarationName :: MemberName, - refReturnPropertyDeclarationBody :: RefPropertyBody} - deriving (Eq, Ord, Read, Show) - -_RefReturnPropertyDeclaration = Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration" - -_RefReturnPropertyDeclaration_attributes = Core.Name "attributes" - -_RefReturnPropertyDeclaration_modifiers = Core.Name "modifiers" - -_RefReturnPropertyDeclaration_refKind = Core.Name "refKind" - -_RefReturnPropertyDeclaration_type = Core.Name "type" - -_RefReturnPropertyDeclaration_name = Core.Name "name" - -_RefReturnPropertyDeclaration_body = Core.Name "body" - --- | An implicitly typed local variable declared by reference using 'ref var'. -data RefVarImplicitlyTypedLocalVariableDeclaration = - RefVarImplicitlyTypedLocalVariableDeclaration { - refVarImplicitlyTypedLocalVariableDeclarationRefKind :: RefKind, - refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: RefLocalVariableDeclarator} - deriving (Eq, Ord, Read, Show) - -_RefVarImplicitlyTypedLocalVariableDeclaration = - Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration" - -_RefVarImplicitlyTypedLocalVariableDeclaration_refKind = Core.Name "refKind" - -_RefVarImplicitlyTypedLocalVariableDeclaration_declarator = Core.Name "declarator" - --- | A reference type: class, interface, array, delegate, or the dynamic type. -data ReferenceType = - ReferenceTypeClass ClassType | - ReferenceTypeInterface InterfaceType | - ReferenceTypeArray ArrayType | - ReferenceTypeDelegate DelegateType | - ReferenceTypeDynamic - deriving (Eq, Ord, Read, Show) - -_ReferenceType = Core.Name "hydra.csharp.syntax.ReferenceType" - -_ReferenceType_class = Core.Name "class" - -_ReferenceType_interface = Core.Name "interface" - -_ReferenceType_array = Core.Name "array" - -_ReferenceType_delegate = Core.Name "delegate" - -_ReferenceType_dynamic = Core.Name "dynamic" - --- | A single '{expression[,width][:format]}' hole within a regular interpolated string. -data RegularInterpolation = - RegularInterpolation { - regularInterpolationExpression :: Expression, - regularInterpolationWidth :: (Maybe Expression), - regularInterpolationFormat :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_RegularInterpolation = Core.Name "hydra.csharp.syntax.RegularInterpolation" - -_RegularInterpolation_expression = Core.Name "expression" - -_RegularInterpolation_width = Core.Name "width" - -_RegularInterpolation_format = Core.Name "format" - --- | A simple, binary, is-type, is-pattern, or as-type relational expression. -data RelationalExpression = - RelationalExpressionSimple ShiftExpression | - RelationalExpressionBinary BinaryRelationalExpression | - RelationalExpressionIsType IsTypeExpression | - RelationalExpressionIsPattern IsPatternExpression | - RelationalExpressionAsType AsTypeExpression - deriving (Eq, Ord, Read, Show) - -_RelationalExpression = Core.Name "hydra.csharp.syntax.RelationalExpression" - -_RelationalExpression_simple = Core.Name "simple" - -_RelationalExpression_binary = Core.Name "binary" - -_RelationalExpression_isType = Core.Name "isType" - -_RelationalExpression_isPattern = Core.Name "isPattern" - -_RelationalExpression_asType = Core.Name "asType" - --- | A relational comparison operator: less than, greater than, or their or-equal variants. -data RelationalOperator = - RelationalOperatorLessThan | - RelationalOperatorGreaterThan | - RelationalOperatorLessThanOrEqual | - RelationalOperatorGreaterThanOrEqual - deriving (Eq, Ord, Read, Show) - -_RelationalOperator = Core.Name "hydra.csharp.syntax.RelationalOperator" - -_RelationalOperator_lessThan = Core.Name "lessThan" - -_RelationalOperator_greaterThan = Core.Name "greaterThan" - -_RelationalOperator_lessThanOrEqual = Core.Name "lessThanOrEqual" - -_RelationalOperator_greaterThanOrEqual = Core.Name "greaterThanOrEqual" - --- | The resource acquired by a using statement: a local variable declaration or an expression. -data ResourceAcquisition = - ResourceAcquisitionLocal LocalVariableDeclaration | - ResourceAcquisitionExpression Expression - deriving (Eq, Ord, Read, Show) - -_ResourceAcquisition = Core.Name "hydra.csharp.syntax.ResourceAcquisition" - -_ResourceAcquisition_local = Core.Name "local" - -_ResourceAcquisition_expression = Core.Name "expression" - --- | A return statement, in its value-less, value-returning, or ref-returning form. -data ReturnStatement = - ReturnStatementSimple | - ReturnStatementValue Expression | - ReturnStatementRef VariableReference - deriving (Eq, Ord, Read, Show) - -_ReturnStatement = Core.Name "hydra.csharp.syntax.ReturnStatement" - -_ReturnStatement_simple = Core.Name "simple" - -_ReturnStatement_value = Core.Name "value" - -_ReturnStatement_ref = Core.Name "ref" - --- | The declared return type of a member: a ref-qualified type, or void. -data ReturnType = - ReturnTypeRef Type | - ReturnTypeVoid - deriving (Eq, Ord, Read, Show) - -_ReturnType = Core.Name "hydra.csharp.syntax.ReturnType" - -_ReturnType_ref = Core.Name "ref" - -_ReturnType_void = Core.Name "void" - --- | A secondary type-parameter constraint: an interface type or another type parameter. -data SecondaryConstraint = - SecondaryConstraintInterface InterfaceType | - SecondaryConstraintParameter TypeParameter - deriving (Eq, Ord, Read, Show) - -_SecondaryConstraint = Core.Name "hydra.csharp.syntax.SecondaryConstraint" - -_SecondaryConstraint_interface = Core.Name "interface" - -_SecondaryConstraint_parameter = Core.Name "parameter" - --- | A non-empty list of secondary constraints on a type parameter. -newtype SecondaryConstraints = - SecondaryConstraints { - unSecondaryConstraints :: [SecondaryConstraint]} - deriving (Eq, Ord, Read, Show) - -_SecondaryConstraints = Core.Name "hydra.csharp.syntax.SecondaryConstraints" - --- | The final clause of a query body: a 'select' projection or a 'group by' clause. -data SelectOrGroupClause = - SelectOrGroupClauseSelect Expression | - SelectOrGroupClauseGroup GroupClause - deriving (Eq, Ord, Read, Show) - -_SelectOrGroupClause = Core.Name "hydra.csharp.syntax.SelectOrGroupClause" - -_SelectOrGroupClause_select = Core.Name "select" - -_SelectOrGroupClause_group = Core.Name "group" - --- | An if or switch statement. -data SelectionStatement = - SelectionStatementIf IfStatement | - SelectionStatementSwitch SwitchStatement - deriving (Eq, Ord, Read, Show) - -_SelectionStatement = Core.Name "hydra.csharp.syntax.SelectionStatement" - -_SelectionStatement_if = Core.Name "if" - -_SelectionStatement_switch = Core.Name "switch" - --- | A simple additive expression or a binary left/right-shift expression. -data ShiftExpression = - ShiftExpressionSimple AdditiveExpression | - ShiftExpressionBinary BinaryShiftExpression - deriving (Eq, Ord, Read, Show) - -_ShiftExpression = Core.Name "hydra.csharp.syntax.ShiftExpression" - -_ShiftExpression_simple = Core.Name "simple" - -_ShiftExpression_binary = Core.Name "binary" - --- | The left-shift (<<) or right-shift (>>) operator. -data ShiftOperator = - ShiftOperatorLeft | - ShiftOperatorRight - deriving (Eq, Ord, Read, Show) - -_ShiftOperator = Core.Name "hydra.csharp.syntax.ShiftOperator" - -_ShiftOperator_left = Core.Name "left" - -_ShiftOperator_right = Core.Name "right" - --- | The ordinary ternary conditional expression: 'condition ? true : false'. -data SimpleConditionalExpression = - SimpleConditionalExpression { - simpleConditionalExpressionCondition :: NullCoalescingExpression, - simpleConditionalExpressionTrue :: Expression, - simpleConditionalExpressionFalse :: Expression} - deriving (Eq, Ord, Read, Show) - -_SimpleConditionalExpression = Core.Name "hydra.csharp.syntax.SimpleConditionalExpression" - -_SimpleConditionalExpression_condition = Core.Name "condition" - -_SimpleConditionalExpression_true = Core.Name "true" - -_SimpleConditionalExpression_false = Core.Name "false" - --- | A simple identifier reference, with an optional list of explicit type arguments. -data SimpleName = - SimpleName { - simpleNameIdentifier :: Identifier, - simpleNameTypeArguments :: (Maybe TypeArgumentList)} - deriving (Eq, Ord, Read, Show) - -_SimpleName = Core.Name "hydra.csharp.syntax.SimpleName" - -_SimpleName_identifier = Core.Name "identifier" - -_SimpleName_typeArguments = Core.Name "typeArguments" - --- | A numeric type or the bool type. -data SimpleType = - SimpleTypeNumeric NumericType | - SimpleTypeBool - deriving (Eq, Ord, Read, Show) - -_SimpleType = Core.Name "hydra.csharp.syntax.SimpleType" - -_SimpleType_numeric = Core.Name "numeric" - -_SimpleType_bool = Core.Name "bool" - --- | A catch clause naming an exception type and/or filter, with a handler block. -data SpecificCatchClause = - SpecificCatchClause { - specificCatchClauseSpecifier :: (Maybe ExceptionSpecifier), - specificCatchClauseFilter :: (Maybe BooleanExpression), - specificCatchClauseBody :: Block} - deriving (Eq, Ord, Read, Show) - -_SpecificCatchClause = Core.Name "hydra.csharp.syntax.SpecificCatchClause" - -_SpecificCatchClause_specifier = Core.Name "specifier" - -_SpecificCatchClause_filter = Core.Name "filter" - -_SpecificCatchClause_body = Core.Name "body" - --- | A 'stackalloc' expression that allocates a block of memory on the stack. -data StackallocExpression = - StackallocExpression { - stackallocExpressionType :: (Maybe UnmanagedType), - stackallocExpressionExpression :: (Maybe ConstantExpression), - stackallocExpressionInitializer :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_StackallocExpression = Core.Name "hydra.csharp.syntax.StackallocExpression" - -_StackallocExpression_type = Core.Name "type" - -_StackallocExpression_expression = Core.Name "expression" - -_StackallocExpression_initializer = Core.Name "initializer" - --- | A field-like event declaration, with its type and one or more declarators. -data StandardEventDeclaration = - StandardEventDeclaration { - standardEventDeclarationAttributes :: (Maybe Attributes), - standardEventDeclarationModifiers :: [EventModifier], - standardEventDeclarationType :: Type, - standardEventDeclarationDeclarators :: VariableDeclarators} - deriving (Eq, Ord, Read, Show) - -_StandardEventDeclaration = Core.Name "hydra.csharp.syntax.StandardEventDeclaration" - -_StandardEventDeclaration_attributes = Core.Name "attributes" - -_StandardEventDeclaration_modifiers = Core.Name "modifiers" - -_StandardEventDeclaration_type = Core.Name "type" - -_StandardEventDeclaration_declarators = Core.Name "declarators" - --- | A standard (non-ref-returning) indexer declaration. -data StandardIndexerDeclaration = - StandardIndexerDeclaration { - standardIndexerDeclarationAttributes :: (Maybe Attributes), - standardIndexerDeclarationModifiers :: [IndexerModifier], - standardIndexerDeclarationDeclarator :: IndexerDeclarator, - standardIndexerDeclarationBody :: IndexerBody} - deriving (Eq, Ord, Read, Show) - -_StandardIndexerDeclaration = Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration" - -_StandardIndexerDeclaration_attributes = Core.Name "attributes" - -_StandardIndexerDeclaration_modifiers = Core.Name "modifiers" - -_StandardIndexerDeclaration_declarator = Core.Name "declarator" - -_StandardIndexerDeclaration_body = Core.Name "body" - --- | A standard (non-ref-returning) local function declaration. -data StandardLocalFunctionDeclaration = - StandardLocalFunctionDeclaration { - standardLocalFunctionDeclarationModifiers :: [LocalFunctionModifier], - standardLocalFunctionDeclarationReturnType :: ReturnType, - standardLocalFunctionDeclarationHeader :: LocalFunctionHeader, - standardLocalFunctionDeclarationBody :: LocalFunctionBody} - deriving (Eq, Ord, Read, Show) - -_StandardLocalFunctionDeclaration = Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration" - -_StandardLocalFunctionDeclaration_modifiers = Core.Name "modifiers" - -_StandardLocalFunctionDeclaration_returnType = Core.Name "returnType" - -_StandardLocalFunctionDeclaration_header = Core.Name "header" - -_StandardLocalFunctionDeclaration_body = Core.Name "body" - --- | A standard (non-ref-returning) method declaration. -data StandardMethodDeclaration = - StandardMethodDeclaration { - standardMethodDeclarationAttributes :: (Maybe Attributes), - standardMethodDeclarationModifiers :: [MethodModifier], - standardMethodDeclarationReturnType :: ReturnType, - standardMethodDeclarationHeader :: MethodHeader, - standardMethodDeclarationBody :: MethodBody} - deriving (Eq, Ord, Read, Show) - -_StandardMethodDeclaration = Core.Name "hydra.csharp.syntax.StandardMethodDeclaration" - -_StandardMethodDeclaration_attributes = Core.Name "attributes" - -_StandardMethodDeclaration_modifiers = Core.Name "modifiers" - -_StandardMethodDeclaration_returnType = Core.Name "returnType" - -_StandardMethodDeclaration_header = Core.Name "header" - -_StandardMethodDeclaration_body = Core.Name "body" - --- | A standard (non-ref-returning) property declaration. -data StandardPropertyDeclaration = - StandardPropertyDeclaration { - standardPropertyDeclarationAttributes :: (Maybe Attributes), - standardPropertyDeclarationModifiers :: [PropertyModifier], - standardPropertyDeclarationType :: Type, - standardPropertyDeclarationName :: MemberName, - standardPropertyDeclarationBody :: PropertyBody} - deriving (Eq, Ord, Read, Show) - -_StandardPropertyDeclaration = Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration" - -_StandardPropertyDeclaration_attributes = Core.Name "attributes" - -_StandardPropertyDeclaration_modifiers = Core.Name "modifiers" - -_StandardPropertyDeclaration_type = Core.Name "type" - -_StandardPropertyDeclaration_name = Core.Name "name" - -_StandardPropertyDeclaration_body = Core.Name "body" - --- | A labeled statement, a declaration statement, or an embedded statement. -data Statement = - StatementLabeled LabeledStatement | - StatementDeclaration DeclarationStatement | - StatementEmbedded EmbeddedStatement - deriving (Eq, Ord, Read, Show) - -_Statement = Core.Name "hydra.csharp.syntax.Statement" - -_Statement_labeled = Core.Name "labeled" - -_Statement_declaration = Core.Name "declaration" - -_Statement_embedded = Core.Name "embedded" - --- | An expression usable as a statement on its own, such as an invocation or assignment. -data StatementExpression = - StatementExpressionNullConditionalInvocation NullConditionalInvocationExpression | - StatementExpressionInvocation InvocationExpression | - StatementExpressionObjectCreation ObjectCreationExpression | - StatementExpressionAssignment Assignment | - StatementExpressionPostIncrement PrimaryExpression | - StatementExpressionPostDecrement PrimaryExpression | - StatementExpressionPreIncrement UnaryExpression | - StatementExpressionPreDecrement UnaryExpression | - StatementExpressionAwait UnaryExpression - deriving (Eq, Ord, Read, Show) - -_StatementExpression = Core.Name "hydra.csharp.syntax.StatementExpression" - -_StatementExpression_nullConditionalInvocation = Core.Name "nullConditionalInvocation" - -_StatementExpression_invocation = Core.Name "invocation" - -_StatementExpression_objectCreation = Core.Name "objectCreation" - -_StatementExpression_assignment = Core.Name "assignment" - -_StatementExpression_postIncrement = Core.Name "postIncrement" - -_StatementExpression_postDecrement = Core.Name "postDecrement" - -_StatementExpression_preIncrement = Core.Name "preIncrement" - -_StatementExpression_preDecrement = Core.Name "preDecrement" - -_StatementExpression_await = Core.Name "await" - --- | A non-empty, comma-separated list of statement expressions, as used in a for statement. -newtype StatementExpressionList = - StatementExpressionList { - unStatementExpressionList :: [StatementExpression]} - deriving (Eq, Ord, Read, Show) - -_StatementExpressionList = Core.Name "hydra.csharp.syntax.StatementExpressionList" - --- | The body of a static constructor: a block, expression body, or empty (extern) body. -data StaticConstructorBody = - StaticConstructorBodyBlock Block | - StaticConstructorBodyExpression Expression | - StaticConstructorBodyEmpty - deriving (Eq, Ord, Read, Show) - -_StaticConstructorBody = Core.Name "hydra.csharp.syntax.StaticConstructorBody" - -_StaticConstructorBody_block = Core.Name "block" - -_StaticConstructorBody_expression = Core.Name "expression" - -_StaticConstructorBody_empty = Core.Name "empty" - --- | A static constructor declaration for a type. -data StaticConstructorDeclaration = - StaticConstructorDeclaration { - staticConstructorDeclarationAttributes :: (Maybe Attributes), - staticConstructorDeclarationModifiers :: StaticConstructorModifiers, - staticConstructorDeclarationName :: Identifier, - staticConstructorDeclarationBody :: StaticConstructorBody} - deriving (Eq, Ord, Read, Show) - -_StaticConstructorDeclaration = Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration" - -_StaticConstructorDeclaration_attributes = Core.Name "attributes" - -_StaticConstructorDeclaration_modifiers = Core.Name "modifiers" - -_StaticConstructorDeclaration_name = Core.Name "name" - -_StaticConstructorDeclaration_body = Core.Name "body" - --- | The extern and unsafe flags of a static constructor declaration. -data StaticConstructorModifiers = - StaticConstructorModifiers { - staticConstructorModifiersExtern :: Bool, - staticConstructorModifiersUnsafe :: Bool} - deriving (Eq, Ord, Read, Show) - -_StaticConstructorModifiers = Core.Name "hydra.csharp.syntax.StaticConstructorModifiers" - -_StaticConstructorModifiers_extern = Core.Name "extern" - -_StaticConstructorModifiers_unsafe = Core.Name "unsafe" - --- | A struct type declaration, with its modifiers, type parameters, interfaces, and body. -data StructDeclaration = - StructDeclaration { - structDeclarationAttributes :: (Maybe Attributes), - structDeclarationModifiers :: [StructModifier], - structDeclarationRef :: Bool, - structDeclarationPartial :: Bool, - structDeclarationName :: Identifier, - structDeclarationParameters :: (Maybe TypeParameterList), - structDeclarationInterfaces :: [InterfaceType], - structDeclarationConstraints :: [TypeParameterConstraintsClause], - structDeclarationBody :: [StructMemberDeclaration]} - deriving (Eq, Ord, Read, Show) - -_StructDeclaration = Core.Name "hydra.csharp.syntax.StructDeclaration" - -_StructDeclaration_attributes = Core.Name "attributes" - -_StructDeclaration_modifiers = Core.Name "modifiers" - -_StructDeclaration_ref = Core.Name "ref" - -_StructDeclaration_partial = Core.Name "partial" - -_StructDeclaration_name = Core.Name "name" - -_StructDeclaration_parameters = Core.Name "parameters" - -_StructDeclaration_interfaces = Core.Name "interfaces" - -_StructDeclaration_constraints = Core.Name "constraints" - -_StructDeclaration_body = Core.Name "body" - --- | Any member that can appear in a struct body, including fixed-size buffer declarations. -data StructMemberDeclaration = - StructMemberDeclarationConstant ConstantDeclaration | - StructMemberDeclarationField FieldDeclaration | - StructMemberDeclarationMethod MethodDeclaration | - StructMemberDeclarationProperty PropertyDeclaration | - StructMemberDeclarationEvent EventDeclaration | - StructMemberDeclarationIndexer IndexerDeclaration | - StructMemberDeclarationOperator OperatorDeclaration | - StructMemberDeclarationConstructor ConstructorDeclaration | - StructMemberDeclarationStaticConstructor StaticConstructorDeclaration | - StructMemberDeclarationType TypeDeclaration | - StructMemberDeclarationFixedSizeBuffer FixedSizeBufferDeclaration - deriving (Eq, Ord, Read, Show) - -_StructMemberDeclaration = Core.Name "hydra.csharp.syntax.StructMemberDeclaration" - -_StructMemberDeclaration_constant = Core.Name "constant" - -_StructMemberDeclaration_field = Core.Name "field" - -_StructMemberDeclaration_method = Core.Name "method" - -_StructMemberDeclaration_property = Core.Name "property" - -_StructMemberDeclaration_event = Core.Name "event" - -_StructMemberDeclaration_indexer = Core.Name "indexer" - -_StructMemberDeclaration_operator = Core.Name "operator" - -_StructMemberDeclaration_constructor = Core.Name "constructor" - -_StructMemberDeclaration_staticConstructor = Core.Name "staticConstructor" - -_StructMemberDeclaration_type = Core.Name "type" - -_StructMemberDeclaration_fixedSizeBuffer = Core.Name "fixedSizeBuffer" - --- | A modifier keyword on a struct declaration, such as readonly or unsafe. -data StructModifier = - StructModifierNew | - StructModifierPublic | - StructModifierProtected | - StructModifierInternal | - StructModifierPrivate | - StructModifierReadonly | - StructModifierUnsafe - deriving (Eq, Ord, Read, Show) - -_StructModifier = Core.Name "hydra.csharp.syntax.StructModifier" - -_StructModifier_new = Core.Name "new" - -_StructModifier_public = Core.Name "public" - -_StructModifier_protected = Core.Name "protected" - -_StructModifier_internal = Core.Name "internal" - -_StructModifier_private = Core.Name "private" - -_StructModifier_readonly = Core.Name "readonly" - -_StructModifier_unsafe = Core.Name "unsafe" - --- | A struct type or an enum type, as used in the definition of value types. -data StructOrEnumType = - StructOrEnumTypeStruct StructType | - StructOrEnumTypeEnum EnumType - deriving (Eq, Ord, Read, Show) - -_StructOrEnumType = Core.Name "hydra.csharp.syntax.StructOrEnumType" - -_StructOrEnumType_struct = Core.Name "struct" - -_StructOrEnumType_enum = Core.Name "enum" - --- | A reference to a struct type: a named type, a simple type, or a tuple type. -data StructType = - StructTypeTypeName TypeName | - StructTypeSimple SimpleType | - StructTypeTuple TupleType - deriving (Eq, Ord, Read, Show) - -_StructType = Core.Name "hydra.csharp.syntax.StructType" - -_StructType_typeName = Core.Name "typeName" - -_StructType_simple = Core.Name "simple" - -_StructType_tuple = Core.Name "tuple" - --- | A pattern and optional guard expression used in a pattern-matching switch section. -data SwitchBranch = - SwitchBranch { - switchBranchPattern :: Pattern, - switchBranchGuard :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_SwitchBranch = Core.Name "hydra.csharp.syntax.SwitchBranch" - -_SwitchBranch_pattern = Core.Name "pattern" - -_SwitchBranch_guard = Core.Name "guard" - --- | A single label of a switch section: a pattern branch, or the default label. -data SwitchLabel = - SwitchLabelBranch SwitchBranch | - SwitchLabelDefault - deriving (Eq, Ord, Read, Show) - -_SwitchLabel = Core.Name "hydra.csharp.syntax.SwitchLabel" - -_SwitchLabel_branch = Core.Name "branch" - -_SwitchLabel_default = Core.Name "default" - --- | A group of switch labels sharing a common statement list within a switch statement. -data SwitchSection = - SwitchSection { - switchSectionLabels :: [SwitchLabel], - switchSectionStatements :: [Statement]} - deriving (Eq, Ord, Read, Show) - -_SwitchSection = Core.Name "hydra.csharp.syntax.SwitchSection" - -_SwitchSection_labels = Core.Name "labels" - -_SwitchSection_statements = Core.Name "statements" - --- | A switch statement, dispatching on an expression across its switch sections. -data SwitchStatement = - SwitchStatement { - switchStatementExpression :: Expression, - switchStatementBranches :: [SwitchSection]} - deriving (Eq, Ord, Read, Show) - -_SwitchStatement = Core.Name "hydra.csharp.syntax.SwitchStatement" - -_SwitchStatement_expression = Core.Name "expression" - -_SwitchStatement_branches = Core.Name "branches" - --- | A try statement with its protected block, catch clauses, and optional finally block. -data TryStatement = - TryStatement { - tryStatementBody :: Block, - tryStatementCatches :: CatchClauses, - tryStatementFinally :: (Maybe Block)} - deriving (Eq, Ord, Read, Show) - -_TryStatement = Core.Name "hydra.csharp.syntax.TryStatement" - -_TryStatement_body = Core.Name "body" - -_TryStatement_catches = Core.Name "catches" - -_TryStatement_finally = Core.Name "finally" - --- | A single element of a tuple expression, with an optional name. -data TupleElement = - TupleElement { - tupleElementName :: (Maybe Identifier), - tupleElementExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_TupleElement = Core.Name "hydra.csharp.syntax.TupleElement" - -_TupleElement_name = Core.Name "name" - -_TupleElement_expression = Core.Name "expression" - --- | A tuple literal expression, either a list of named elements or a deconstruction tuple. -data TupleExpression = - TupleExpressionElements [TupleElement] | - TupleExpressionDeconstruction DeconstructionTuple - deriving (Eq, Ord, Read, Show) - -_TupleExpression = Core.Name "hydra.csharp.syntax.TupleExpression" - -_TupleExpression_elements = Core.Name "elements" - -_TupleExpression_deconstruction = Core.Name "deconstruction" - --- | A tuple type formed from a non-empty list of named or unnamed element types. -newtype TupleType = - TupleType { - unTupleType :: [TupleTypeElement]} - deriving (Eq, Ord, Read, Show) - -_TupleType = Core.Name "hydra.csharp.syntax.TupleType" - --- | A single element type of a tuple type, with an optional element name. -data TupleTypeElement = - TupleTypeElement { - tupleTypeElementType :: Type, - tupleTypeElementIdentifier :: (Maybe Identifier)} - deriving (Eq, Ord, Read, Show) - -_TupleTypeElement = Core.Name "hydra.csharp.syntax.TupleTypeElement" - -_TupleTypeElement_type = Core.Name "type" - -_TupleTypeElement_identifier = Core.Name "identifier" - --- | A C# type: a reference type, value type, type parameter, or pointer type. -data Type = - TypeReference ReferenceType | - TypeValue ValueType | - TypeParam TypeParameter | - TypePointer PointerType - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.csharp.syntax.Type" - -_Type_reference = Core.Name "reference" - -_Type_value = Core.Name "value" - -_Type_param = Core.Name "param" - -_Type_pointer = Core.Name "pointer" - --- | A list of type arguments supplied to a generic type or method. -newtype TypeArgumentList = - TypeArgumentList { - unTypeArgumentList :: [Type]} - deriving (Eq, Ord, Read, Show) - -_TypeArgumentList = Core.Name "hydra.csharp.syntax.TypeArgumentList" - --- | A top-level or nested type declaration: class, struct, interface, enum, or delegate. -data TypeDeclaration = - TypeDeclarationClass ClassDeclaration | - TypeDeclarationStruct StructDeclaration | - TypeDeclarationInterface InterfaceDeclaration | - TypeDeclarationEnum EnumDeclaration | - TypeDeclarationDelegate DelegateDeclaration - deriving (Eq, Ord, Read, Show) - -_TypeDeclaration = Core.Name "hydra.csharp.syntax.TypeDeclaration" - -_TypeDeclaration_class = Core.Name "class" - -_TypeDeclaration_struct = Core.Name "struct" - -_TypeDeclaration_interface = Core.Name "interface" - -_TypeDeclaration_enum = Core.Name "enum" - -_TypeDeclaration_delegate = Core.Name "delegate" - --- | A name that is known to refer to a type, expressed as a namespace-or-type name. -newtype TypeName = - TypeName { - unTypeName :: NamespaceOrTypeName} - deriving (Eq, Ord, Read, Show) - -_TypeName = Core.Name "hydra.csharp.syntax.TypeName" - --- | A single generic type parameter, identified by its name. -newtype TypeParameter = - TypeParameter { - unTypeParameter :: Identifier} - deriving (Eq, Ord, Read, Show) - -_TypeParameter = Core.Name "hydra.csharp.syntax.TypeParameter" - --- | The primary, secondary, and constructor constraints on a single type parameter. -data TypeParameterConstraints = - TypeParameterConstraints { - typeParameterConstraintsPrimary :: (Maybe PrimaryConstraint), - typeParameterConstraintsSecondary :: (Maybe SecondaryConstraints), - typeParameterConstraintsConstructor :: Bool} - deriving (Eq, Ord, Read, Show) - -_TypeParameterConstraints = Core.Name "hydra.csharp.syntax.TypeParameterConstraints" - -_TypeParameterConstraints_primary = Core.Name "primary" - -_TypeParameterConstraints_secondary = Core.Name "secondary" - -_TypeParameterConstraints_constructor = Core.Name "constructor" - --- | A 'where T : ...' clause constraining one type parameter of a generic declaration. -data TypeParameterConstraintsClause = - TypeParameterConstraintsClause { - typeParameterConstraintsClauseParameter :: TypeParameter, - typeParameterConstraintsClauseConstraints :: [TypeParameterConstraints]} - deriving (Eq, Ord, Read, Show) - -_TypeParameterConstraintsClause = Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause" - -_TypeParameterConstraintsClause_parameter = Core.Name "parameter" - -_TypeParameterConstraintsClause_constraints = Core.Name "constraints" - --- | A non-empty, comma-separated list of type parameters in a generic declaration. -newtype TypeParameterList = - TypeParameterList { - unTypeParameterList :: [TypeParameterPart]} - deriving (Eq, Ord, Read, Show) - -_TypeParameterList = Core.Name "hydra.csharp.syntax.TypeParameterList" - --- | A single type parameter within a type parameter list, with its optional attributes. -data TypeParameterPart = - TypeParameterPart { - typeParameterPartAttributes :: (Maybe Attributes), - typeParameterPartName :: TypeParameter} - deriving (Eq, Ord, Read, Show) - -_TypeParameterPart = Core.Name "hydra.csharp.syntax.TypeParameterPart" - -_TypeParameterPart_attributes = Core.Name "attributes" - -_TypeParameterPart_name = Core.Name "name" - --- | A 'typeof' expression yielding the System.Type of a type, unbound generic type, or void. -data TypeofExpression = - TypeofExpressionType Type | - TypeofExpressionUnboundTypeName UnboundTypeName | - TypeofExpressionVoid - deriving (Eq, Ord, Read, Show) - -_TypeofExpression = Core.Name "hydra.csharp.syntax.TypeofExpression" - -_TypeofExpression_type = Core.Name "type" - -_TypeofExpression_unboundTypeName = Core.Name "unboundTypeName" - -_TypeofExpression_void = Core.Name "void" - --- | A unary expression: a primary expression, or a prefixed unary/cast/await operation. -data UnaryExpression = - UnaryExpressionPrimary PrimaryExpression | - UnaryExpressionPlus UnaryExpression | - UnaryExpressionMinus UnaryExpression | - UnaryExpressionNot UnaryExpression | - UnaryExpressionBitwiseComplement UnaryExpression | - UnaryExpressionPreIncrement UnaryExpression | - UnaryExpressionPreDecrement UnaryExpression | - UnaryExpressionCast CastExpression | - UnaryExpressionAwait UnaryExpression | - UnaryExpressionPointerIndirection UnaryExpression | - UnaryExpressionAddressOf UnaryExpression - deriving (Eq, Ord, Read, Show) - -_UnaryExpression = Core.Name "hydra.csharp.syntax.UnaryExpression" - -_UnaryExpression_primary = Core.Name "primary" - -_UnaryExpression_plus = Core.Name "plus" - -_UnaryExpression_minus = Core.Name "minus" - -_UnaryExpression_not = Core.Name "not" - -_UnaryExpression_bitwiseComplement = Core.Name "bitwiseComplement" - -_UnaryExpression_preIncrement = Core.Name "preIncrement" - -_UnaryExpression_preDecrement = Core.Name "preDecrement" - -_UnaryExpression_cast = Core.Name "cast" - -_UnaryExpression_await = Core.Name "await" - -_UnaryExpression_pointerIndirection = Core.Name "pointerIndirection" - -_UnaryExpression_addressOf = Core.Name "addressOf" - --- | The declarator for a user-defined unary operator overload, naming its single parameter. -data UnaryOperatorDeclarator = - UnaryOperatorDeclarator { - unaryOperatorDeclaratorType :: Type, - unaryOperatorDeclaratorOperator :: OverloadableUnaryOperator, - unaryOperatorDeclaratorParameter :: FixedParameter} - deriving (Eq, Ord, Read, Show) - -_UnaryOperatorDeclarator = Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator" - -_UnaryOperatorDeclarator_type = Core.Name "type" - -_UnaryOperatorDeclarator_operator = Core.Name "operator" - -_UnaryOperatorDeclarator_parameter = Core.Name "parameter" - --- | An unbound generic type name, as used in a typeof expression (e.g. Dictionary<,>). -newtype UnboundTypeName = - UnboundTypeName { - unUnboundTypeName :: [UnboundTypeNamePart]} - deriving (Eq, Ord, Read, Show) - -_UnboundTypeName = Core.Name "hydra.csharp.syntax.UnboundTypeName" - --- | A single segment of an unbound type name, with its aliasing flag and generic dimension. -data UnboundTypeNamePart = - UnboundTypeNamePart { - unboundTypeNamePartIdentifier :: Identifier, - unboundTypeNamePartAliased :: Bool, - unboundTypeNamePartDimension :: (Maybe Int)} - deriving (Eq, Ord, Read, Show) - -_UnboundTypeNamePart = Core.Name "hydra.csharp.syntax.UnboundTypeNamePart" - -_UnboundTypeNamePart_identifier = Core.Name "identifier" - -_UnboundTypeNamePart_aliased = Core.Name "aliased" - -_UnboundTypeNamePart_dimension = Core.Name "dimension" - --- | A type usable with the unsafe 'sizeof' operator: a value type or pointer type. -data UnmanagedType = - UnmanagedTypeValue ValueType | - UnmanagedTypePointer PointerType - deriving (Eq, Ord, Read, Show) - -_UnmanagedType = Core.Name "hydra.csharp.syntax.UnmanagedType" - -_UnmanagedType_value = Core.Name "value" - -_UnmanagedType_pointer = Core.Name "pointer" - --- | A 'using alias = namespace-or-type;' directive introducing a using alias. -data UsingAliasDirective = - UsingAliasDirective { - usingAliasDirectiveAlias :: Identifier, - usingAliasDirectiveName :: NamespaceOrTypeName} - deriving (Eq, Ord, Read, Show) - -_UsingAliasDirective = Core.Name "hydra.csharp.syntax.UsingAliasDirective" - -_UsingAliasDirective_alias = Core.Name "alias" - -_UsingAliasDirective_name = Core.Name "name" - --- | A using directive: an alias directive, a namespace import, or a using-static directive. -data UsingDirective = - UsingDirectiveAlias UsingAliasDirective | - UsingDirectiveNamespace NamespaceName | - UsingDirectiveStatic TypeName - deriving (Eq, Ord, Read, Show) - -_UsingDirective = Core.Name "hydra.csharp.syntax.UsingDirective" - -_UsingDirective_alias = Core.Name "alias" - -_UsingDirective_namespace = Core.Name "namespace" - -_UsingDirective_static = Core.Name "static" - --- | A 'using' statement that deterministically disposes an acquired resource after its body. -data UsingStatement = - UsingStatement { - usingStatementAcquisition :: ResourceAcquisition, - usingStatementBody :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_UsingStatement = Core.Name "hydra.csharp.syntax.UsingStatement" - -_UsingStatement_acquisition = Core.Name "acquisition" - -_UsingStatement_body = Core.Name "body" - --- | A struct or enum type, in its non-nullable or nullable ('?') form. -data ValueType = - ValueTypeNonNullable StructOrEnumType | - ValueTypeNullable StructOrEnumType - deriving (Eq, Ord, Read, Show) - -_ValueType = Core.Name "hydra.csharp.syntax.ValueType" - -_ValueType_nonNullable = Core.Name "nonNullable" - -_ValueType_nullable = Core.Name "nullable" - --- | An identifier and optional initializer within a field or local variable declaration. -data VariableDeclarator = - VariableDeclarator { - variableDeclaratorIdentifier :: Identifier, - variableDeclaratorInitializer :: (Maybe VariableInitializer)} - deriving (Eq, Ord, Read, Show) - -_VariableDeclarator = Core.Name "hydra.csharp.syntax.VariableDeclarator" - -_VariableDeclarator_identifier = Core.Name "identifier" - -_VariableDeclarator_initializer = Core.Name "initializer" - --- | A non-empty, comma-separated list of variable declarators, as used in an event declaration. -newtype VariableDeclarators = - VariableDeclarators { - unVariableDeclarators :: [VariableDeclarator]} - deriving (Eq, Ord, Read, Show) - -_VariableDeclarators = Core.Name "hydra.csharp.syntax.VariableDeclarators" - --- | The initializer of a variable: an expression or a nested array initializer. -data VariableInitializer = - VariableInitializerExpression Expression | - VariableInitializerArray ArrayInitializer - deriving (Eq, Ord, Read, Show) - -_VariableInitializer = Core.Name "hydra.csharp.syntax.VariableInitializer" - -_VariableInitializer_expression = Core.Name "expression" - -_VariableInitializer_array = Core.Name "array" - --- | A reference to a variable, expressed as an expression. -newtype VariableReference = - VariableReference { - unVariableReference :: Expression} - deriving (Eq, Ord, Read, Show) - -_VariableReference = Core.Name "hydra.csharp.syntax.VariableReference" - --- | The in (contravariant) or out (covariant) variance annotation on a generic type parameter. -data VarianceAnnotation = - VarianceAnnotationIn | - VarianceAnnotationOut - deriving (Eq, Ord, Read, Show) - -_VarianceAnnotation = Core.Name "hydra.csharp.syntax.VarianceAnnotation" - -_VarianceAnnotation_in = Core.Name "in" - -_VarianceAnnotation_out = Core.Name "out" - --- | A single type parameter of an interface or delegate, with optional variance annotation. -data VariantTypeParameter = - VariantTypeParameter { - variantTypeParameterAttributes :: (Maybe Attributes), - variantTypeParameterVariance :: (Maybe VarianceAnnotation), - variantTypeParameterParameter :: TypeParameter} - deriving (Eq, Ord, Read, Show) - -_VariantTypeParameter = Core.Name "hydra.csharp.syntax.VariantTypeParameter" - -_VariantTypeParameter_attributes = Core.Name "attributes" - -_VariantTypeParameter_variance = Core.Name "variance" - -_VariantTypeParameter_parameter = Core.Name "parameter" - --- | The list of variant type parameters declared by a generic interface or delegate. -newtype VariantTypeParameters = - VariantTypeParameters { - unVariantTypeParameters :: [VariantTypeParameter]} - deriving (Eq, Ord, Read, Show) - -_VariantTypeParameters = Core.Name "hydra.csharp.syntax.VariantTypeParameters" - --- | A single '{expression[,width][:format]}' hole within a verbatim interpolated string. -data VerbatimInterpolation = - VerbatimInterpolation { - verbatimInterpolationExpression :: Expression, - verbatimInterpolationWidth :: (Maybe ConstantExpression), - verbatimInterpolationFormat :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_VerbatimInterpolation = Core.Name "hydra.csharp.syntax.VerbatimInterpolation" - -_VerbatimInterpolation_expression = Core.Name "expression" - -_VerbatimInterpolation_width = Core.Name "width" - -_VerbatimInterpolation_format = Core.Name "format" - --- | A while iteration statement that tests its condition before each execution of the body. -data WhileStatement = - WhileStatement { - whileStatementCondition :: BooleanExpression, - whileStatementBody :: EmbeddedStatement} - deriving (Eq, Ord, Read, Show) - -_WhileStatement = Core.Name "hydra.csharp.syntax.WhileStatement" - -_WhileStatement_condition = Core.Name "condition" - -_WhileStatement_body = Core.Name "body" - --- | A 'yield return' or 'yield break' statement used within an iterator. -data YieldStatement = - YieldStatementReturn Expression | - YieldStatementBreak - deriving (Eq, Ord, Read, Show) - -_YieldStatement = Core.Name "hydra.csharp.syntax.YieldStatement" - -_YieldStatement_return = Core.Name "return" - -_YieldStatement_break = Core.Name "break" diff --git a/src/main/haskell/Hydra/Datalog/Syntax.hs b/src/main/haskell/Hydra/Datalog/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Datalog/Syntax.hs +++ /dev/null @@ -1,180 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A basic Datalog model - -module Hydra.Datalog.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A relation applied to a list of terms -data Atom = - Atom { - atomRelation :: Relation, - atomTermList :: TermList} - deriving (Eq, Ord, Read, Show) - -_Atom = Core.Name "hydra.datalog.syntax.Atom" - -_Atom_Relation = Core.Name "Relation" - -_Atom_TermList = Core.Name "TermList" - --- | A nonempty, comma-separated list of atoms -data AtomList = - AtomListSingle Atom | - AtomListMany AtomListMultiple - deriving (Eq, Ord, Read, Show) - -_AtomList = Core.Name "hydra.datalog.syntax.AtomList" - -_AtomList_single = Core.Name "single" - -_AtomList_many = Core.Name "many" - --- | An atom followed by the remainder of a comma-separated atom list -data AtomListMultiple = - AtomListMultiple { - atomListMultipleAtom :: Atom, - atomListMultipleAtomList :: AtomList} - deriving (Eq, Ord, Read, Show) - -_AtomListMultiple = Core.Name "hydra.datalog.syntax.AtomListMultiple" - -_AtomListMultiple_Atom = Core.Name "Atom" - -_AtomListMultiple_AtomList = Core.Name "AtomList" - --- | A constant term, e.g. an atomic value such as a symbol or number -newtype Constant = - Constant { - unConstant :: String} - deriving (Eq, Ord, Read, Show) - -_Constant = Core.Name "hydra.datalog.syntax.Constant" - --- | A nonempty, comma-separated list of constants -data ConstantList = - ConstantListSingle Constant | - ConstantListMany ConstantListMultiple - deriving (Eq, Ord, Read, Show) - -_ConstantList = Core.Name "hydra.datalog.syntax.ConstantList" - -_ConstantList_single = Core.Name "single" - -_ConstantList_many = Core.Name "many" - --- | A constant followed by the remainder of a comma-separated constant list -data ConstantListMultiple = - ConstantListMultiple { - constantListMultipleConstant :: Constant, - constantListMultipleConstantList :: ConstantList} - deriving (Eq, Ord, Read, Show) - -_ConstantListMultiple = Core.Name "hydra.datalog.syntax.ConstantListMultiple" - -_ConstantListMultiple_Constant = Core.Name "Constant" - -_ConstantListMultiple_ConstantList = Core.Name "ConstantList" - --- | An unconditional assertion of a relation applied to a list of constants -data Fact = - Fact { - factRelation :: Relation, - factConstantList :: ConstantList} - deriving (Eq, Ord, Read, Show) - -_Fact = Core.Name "hydra.datalog.syntax.Fact" - -_Fact_Relation = Core.Name "Relation" - -_Fact_ConstantList = Core.Name "ConstantList" - --- | A Datalog program: a list of facts and rules -newtype Program = - Program { - unProgram :: [ProgramElmt]} - deriving (Eq, Ord, Read, Show) - -_Program = Core.Name "hydra.datalog.syntax.Program" - --- | A single element of a Datalog program: either a fact or a rule -data ProgramElmt = - ProgramElmtFact Fact | - ProgramElmtRule Rule - deriving (Eq, Ord, Read, Show) - -_ProgramElmt = Core.Name "hydra.datalog.syntax.ProgramElmt" - -_ProgramElmt_Fact = Core.Name "Fact" - -_ProgramElmt_Rule = Core.Name "Rule" - --- | The name of a predicate (relation) used in facts, rules, and queries -newtype Relation = - Relation { - unRelation :: String} - deriving (Eq, Ord, Read, Show) - -_Relation = Core.Name "hydra.datalog.syntax.Relation" - --- | A conditional assertion: a head atom implied by a conjunction of body atoms -data Rule = - Rule { - ruleAtom :: Atom, - ruleAtomList :: AtomList} - deriving (Eq, Ord, Read, Show) - -_Rule = Core.Name "hydra.datalog.syntax.Rule" - -_Rule_Atom = Core.Name "Atom" - -_Rule_AtomList = Core.Name "AtomList" - --- | An argument to an atom: either a constant or a variable -data Term = - TermConstant Constant | - TermVariable Variable - deriving (Eq, Ord, Read, Show) - -_Term = Core.Name "hydra.datalog.syntax.Term" - -_Term_Constant = Core.Name "Constant" - -_Term_Variable = Core.Name "Variable" - --- | A nonempty, comma-separated list of terms -data TermList = - TermListSingle Term | - TermListMany TermListMultiple - deriving (Eq, Ord, Read, Show) - -_TermList = Core.Name "hydra.datalog.syntax.TermList" - -_TermList_single = Core.Name "single" - -_TermList_many = Core.Name "many" - --- | A term followed by the remainder of a comma-separated term list -data TermListMultiple = - TermListMultiple { - termListMultipleTerm :: Term, - termListMultipleTermList :: TermList} - deriving (Eq, Ord, Read, Show) - -_TermListMultiple = Core.Name "hydra.datalog.syntax.TermListMultiple" - -_TermListMultiple_Term = Core.Name "Term" - -_TermListMultiple_TermList = Core.Name "TermList" - --- | A logic variable, which may be bound to different constants across a query -newtype Variable = - Variable { - unVariable :: String} - deriving (Eq, Ord, Read, Show) - -_Variable = Core.Name "hydra.datalog.syntax.Variable" diff --git a/src/main/haskell/Hydra/Delta/Parquet.hs b/src/main/haskell/Hydra/Delta/Parquet.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Delta/Parquet.hs +++ /dev/null @@ -1,154 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A partial Delta Parquet model, based on DataType and its subclasses as specified in the 3.0.0 Java API: https://docs.delta.io/3.0.0/api/java/kernel/io/delta/kernel/types/DataType.html - -module Hydra.Delta.Parquet where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Represent array data type. -data ArrayType = - ArrayType { - arrayTypeElementType :: DataType, - arrayTypeContainsNull :: Bool} - deriving (Eq, Ord, Read, Show) - -_ArrayType = Core.Name "hydra.delta.parquet.ArrayType" - -_ArrayType_elementType = Core.Name "elementType" - -_ArrayType_containsNull = Core.Name "containsNull" - --- | Base class for all primitive types DataType. -data BasePrimitiveType = - -- | The data type representing byte[] values. - BasePrimitiveTypeBinary | - -- | Data type representing boolean type values. - BasePrimitiveTypeBoolean | - -- | The data type representing byte type values. - BasePrimitiveTypeByte | - -- | A date type, supporting "0001-01-01" through "9999-12-31". Internally, this is represented as the number of days from 1970-01-01. - BasePrimitiveTypeDate | - -- | The data type representing double type values. - BasePrimitiveTypeDouble | - -- | The data type representing float type values. - BasePrimitiveTypeFloat | - -- | The data type representing integer type values. - BasePrimitiveTypeInteger | - -- | The data type representing long type values. - BasePrimitiveTypeLong | - -- | The data type representing short type values. - BasePrimitiveTypeShort | - -- | The data type representing string type values. - BasePrimitiveTypeString | - -- | A timestamp type, supporting [0001-01-01T00:00:00.000000Z, 9999-12-31T23:59:59.999999Z] where the left/right-bound is a date and time of the proleptic Gregorian calendar in UTC+00:00. Internally, this is represented as the number of microseconds since the Unix epoch, 1970-01-01 00:00:00 UTC. - BasePrimitiveTypeTimestamp - deriving (Eq, Ord, Read, Show) - -_BasePrimitiveType = Core.Name "hydra.delta.parquet.BasePrimitiveType" - -_BasePrimitiveType_binary = Core.Name "binary" - -_BasePrimitiveType_boolean = Core.Name "boolean" - -_BasePrimitiveType_byte = Core.Name "byte" - -_BasePrimitiveType_date = Core.Name "date" - -_BasePrimitiveType_double = Core.Name "double" - -_BasePrimitiveType_float = Core.Name "float" - -_BasePrimitiveType_integer = Core.Name "integer" - -_BasePrimitiveType_long = Core.Name "long" - -_BasePrimitiveType_short = Core.Name "short" - -_BasePrimitiveType_string = Core.Name "string" - -_BasePrimitiveType_timestamp = Core.Name "timestamp" - --- | A Delta Parquet data type, either array, primitive, decimal, map, or struct. -data DataType = - -- | Represent array data type. - DataTypeArray ArrayType | - -- | Base class for all primitive types DataType. - DataTypeBase BasePrimitiveType | - -- | A decimal data type. - DataTypeDecimal DecimalType | - -- | Data type representing a map type. - DataTypeMap MapType | - -- | Struct type which contains one or more columns. - DataTypeStruct StructType - deriving (Eq, Ord, Read, Show) - -_DataType = Core.Name "hydra.delta.parquet.DataType" - -_DataType_array = Core.Name "array" - -_DataType_base = Core.Name "base" - -_DataType_decimal = Core.Name "decimal" - -_DataType_map = Core.Name "map" - -_DataType_struct = Core.Name "struct" - --- | A decimal data type with fixed precision (the maximum number of digits) and scale (the number of digits on right side of dot). The precision can be up to 38, scale can also be up to 38 (less or equal to precision). -data DecimalType = - DecimalType { - decimalTypePrecision :: Int, - decimalTypeScale :: Int} - deriving (Eq, Ord, Read, Show) - -_DecimalType = Core.Name "hydra.delta.parquet.DecimalType" - -_DecimalType_precision = Core.Name "precision" - -_DecimalType_scale = Core.Name "scale" - --- | Data type representing a map type. -data MapType = - MapType { - mapTypeKeyType :: DataType, - mapTypeValueType :: DataType, - mapTypeValueContainsNull :: Bool} - deriving (Eq, Ord, Read, Show) - -_MapType = Core.Name "hydra.delta.parquet.MapType" - -_MapType_keyType = Core.Name "keyType" - -_MapType_valueType = Core.Name "valueType" - -_MapType_valueContainsNull = Core.Name "valueContainsNull" - --- | Represents a subfield of StructType with additional properties and metadata. -data StructField = - StructField { - structFieldName :: String, - structFieldDataType :: DataType, - structFieldNullable :: Bool} - deriving (Eq, Ord, Read, Show) - -_StructField = Core.Name "hydra.delta.parquet.StructField" - -_StructField_name = Core.Name "name" - -_StructField_dataType = Core.Name "dataType" - -_StructField_nullable = Core.Name "nullable" - --- | Struct type which contains one or more columns. -data StructType = - StructType { - structTypeFields :: [StructField]} - deriving (Eq, Ord, Read, Show) - -_StructType = Core.Name "hydra.delta.parquet.StructType" - -_StructType_fields = Core.Name "fields" diff --git a/src/main/haskell/Hydra/Ext/Atlas.hs b/src/main/haskell/Hydra/Ext/Atlas.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Atlas.hs @@ -0,0 +1,244 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | The Apache Atlas meta-model +-- | Based on the the org.apache.atlas.model package in the master branch as of 2022-06-01 +-- | https://github.com/apache/atlas/tree/master/intg/src/main/java/org/apache/atlas/model + +module Hydra.Ext.Atlas where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Rdf.Xml.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Int as I +import qualified Data.Map as M +import qualified Data.Set as S + +-- | class that captures details of a struct-attribute. +data AtlasAttributeDef = + AtlasAttributeDef { + atlasAttributeDefName :: (Maybe String), + atlasAttributeDefTypeName :: (Maybe String), + atlasAttributeDefIsOptional :: Bool, + atlasAttributeDefCardinality :: (Maybe AtlasAttributeDefCardinality), + atlasAttributeDefValuesMinCount :: Int, + atlasAttributeDefValuesMaxCount :: Int, + atlasAttributeDefIsUnique :: Bool, + atlasAttributeDefIsIndexable :: Bool, + atlasAttributeDefIncludeInNotification :: Bool, + atlasAttributeDefDefaultValue :: (Maybe String), + atlasAttributeDefDescription :: (Maybe String), + atlasAttributeDefSearchWeight :: Int, + atlasAttributeDefIndexType :: (Maybe AtlasAttributeDefIndexType), + atlasAttributeDefConstraints :: [AtlasConstraintDef], + atlasAttributeDefOptions :: (M.Map String String), + atlasAttributeDefDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_AtlasAttributeDef = Model.Name "hydra.ext.atlas.AtlasAttributeDef" + +_AtlasAttributeDef_name = Model.Name "name" + +_AtlasAttributeDef_typeName = Model.Name "typeName" + +_AtlasAttributeDef_isOptional = Model.Name "isOptional" + +_AtlasAttributeDef_cardinality = Model.Name "cardinality" + +_AtlasAttributeDef_valuesMinCount = Model.Name "valuesMinCount" + +_AtlasAttributeDef_valuesMaxCount = Model.Name "valuesMaxCount" + +_AtlasAttributeDef_isUnique = Model.Name "isUnique" + +_AtlasAttributeDef_isIndexable = Model.Name "isIndexable" + +_AtlasAttributeDef_includeInNotification = Model.Name "includeInNotification" + +_AtlasAttributeDef_defaultValue = Model.Name "defaultValue" + +_AtlasAttributeDef_description = Model.Name "description" + +_AtlasAttributeDef_searchWeight = Model.Name "searchWeight" + +_AtlasAttributeDef_indexType = Model.Name "indexType" + +_AtlasAttributeDef_constraints = Model.Name "constraints" + +_AtlasAttributeDef_options = Model.Name "options" + +_AtlasAttributeDef_displayName = Model.Name "displayName" + +-- | The cardinality of an Atlas attribute: single-valued, a list, or a set +data AtlasAttributeDefCardinality = + AtlasAttributeDefCardinalitySingle | + AtlasAttributeDefCardinalityList | + AtlasAttributeDefCardinalitySet + deriving (Eq, Ord, Read, Show) + +_AtlasAttributeDefCardinality = Model.Name "hydra.ext.atlas.AtlasAttributeDefCardinality" + +_AtlasAttributeDefCardinality_single = Model.Name "single" + +_AtlasAttributeDefCardinality_list = Model.Name "list" + +_AtlasAttributeDefCardinality_set = Model.Name "set" + +-- | The index type of an Atlas attribute +data AtlasAttributeDefIndexType = + AtlasAttributeDefIndexTypeDefault | + AtlasAttributeDefIndexTypeString + deriving (Eq, Ord, Read, Show) + +_AtlasAttributeDefIndexType = Model.Name "hydra.ext.atlas.AtlasAttributeDefIndexType" + +_AtlasAttributeDefIndexType_default = Model.Name "default" + +_AtlasAttributeDefIndexType_string = Model.Name "string" + +-- | Base class that captures common-attributes for all Atlas types. +data AtlasBaseTypeDef = + AtlasBaseTypeDef { + atlasBaseTypeDefCategory :: (Maybe TypeCategory), + atlasBaseTypeDefGuid :: (Maybe String), + atlasBaseTypeDefCreatedBy :: (Maybe String), + atlasBaseTypeDefUpdatedBy :: (Maybe String), + atlasBaseTypeDefCreateTime :: (Maybe Schema.DateTime), + atlasBaseTypeDefUpdateTime :: (Maybe Schema.DateTime), + atlasBaseTypeDefVersion :: (Maybe I.Int64), + atlasBaseTypeDefName :: (Maybe String), + atlasBaseTypeDefDescription :: (Maybe String), + atlasBaseTypeDefTypeVersion :: (Maybe String), + atlasBaseTypeDefServiceType :: (Maybe String), + atlasBaseTypeDefOptions :: (M.Map String String)} + deriving (Eq, Ord, Read, Show) + +_AtlasBaseTypeDef = Model.Name "hydra.ext.atlas.AtlasBaseTypeDef" + +_AtlasBaseTypeDef_category = Model.Name "category" + +_AtlasBaseTypeDef_guid = Model.Name "guid" + +_AtlasBaseTypeDef_createdBy = Model.Name "createdBy" + +_AtlasBaseTypeDef_updatedBy = Model.Name "updatedBy" + +_AtlasBaseTypeDef_createTime = Model.Name "createTime" + +_AtlasBaseTypeDef_updateTime = Model.Name "updateTime" + +_AtlasBaseTypeDef_version = Model.Name "version" + +_AtlasBaseTypeDef_name = Model.Name "name" + +_AtlasBaseTypeDef_description = Model.Name "description" + +_AtlasBaseTypeDef_typeVersion = Model.Name "typeVersion" + +_AtlasBaseTypeDef_serviceType = Model.Name "serviceType" + +_AtlasBaseTypeDef_options = Model.Name "options" + +-- | class that captures details of a constraint. +data AtlasConstraintDef = + AtlasConstraintDef { + atlasConstraintDefType :: (Maybe String), + atlasConstraintDefParams :: (M.Map String String)} + deriving (Eq, Ord, Read, Show) + +_AtlasConstraintDef = Model.Name "hydra.ext.atlas.AtlasConstraintDef" + +_AtlasConstraintDef_type = Model.Name "type" + +_AtlasConstraintDef_params = Model.Name "params" + +-- | class that captures details of a entity-type. +data AtlasEntityDef = + AtlasEntityDef { + atlasEntityDefAsAtlasStruct :: AtlasStructDef, + atlasEntityDefSuperTypes :: (S.Set String), + -- | the value of this field is derived from 'superTypes' specified in all AtlasEntityDef + atlasEntityDefSubTypes :: (S.Set String), + -- | the value of this field is derived from all the relationshipDefs this entityType is referenced in + atlasEntityDefRelationshipAttributeDefs :: [AtlasRelationshipAttributeDef], + -- | the value of this field is derived from all the businessMetadataDefs this entityType is referenced in + atlasEntityDefBusinessAttributeDefs :: (M.Map String [AtlasAttributeDef])} + deriving (Eq, Ord, Read, Show) + +_AtlasEntityDef = Model.Name "hydra.ext.atlas.AtlasEntityDef" + +_AtlasEntityDef_asAtlasStruct = Model.Name "asAtlasStruct" + +_AtlasEntityDef_superTypes = Model.Name "superTypes" + +_AtlasEntityDef_subTypes = Model.Name "subTypes" + +_AtlasEntityDef_relationshipAttributeDefs = Model.Name "relationshipAttributeDefs" + +_AtlasEntityDef_businessAttributeDefs = Model.Name "businessAttributeDefs" + +-- | class that captures details of a struct-attribute. +data AtlasRelationshipAttributeDef = + AtlasRelationshipAttributeDef { + atlasRelationshipAttributeDefAsAtlasAttribute :: AtlasAttributeDef, + atlasRelationshipAttributeDefRelationshipTypeName :: (Maybe String), + atlasRelationshipAttributeDefIsLegacyAttribute :: Bool} + deriving (Eq, Ord, Read, Show) + +_AtlasRelationshipAttributeDef = Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef" + +_AtlasRelationshipAttributeDef_asAtlasAttribute = Model.Name "asAtlasAttribute" + +_AtlasRelationshipAttributeDef_relationshipTypeName = Model.Name "relationshipTypeName" + +_AtlasRelationshipAttributeDef_isLegacyAttribute = Model.Name "isLegacyAttribute" + +-- | class that captures details of a struct-type. +data AtlasStructDef = + AtlasStructDef { + atlasStructDefAsAtlasBaseType :: AtlasBaseTypeDef, + atlasStructDefAttributeDefs :: [AtlasAttributeDef]} + deriving (Eq, Ord, Read, Show) + +_AtlasStructDef = Model.Name "hydra.ext.atlas.AtlasStructDef" + +_AtlasStructDef_asAtlasBaseType = Model.Name "asAtlasBaseType" + +_AtlasStructDef_attributeDefs = Model.Name "attributeDefs" + +-- | The category of an Atlas type definition +data TypeCategory = + TypeCategoryPrimitive | + TypeCategoryObjectIdType | + TypeCategoryEnum | + TypeCategoryStruct | + TypeCategoryClassification | + TypeCategoryEntity | + TypeCategoryArray | + TypeCategoryMap | + TypeCategoryRelationship | + TypeCategoryBusinessMetadata + deriving (Eq, Ord, Read, Show) + +_TypeCategory = Model.Name "hydra.ext.atlas.TypeCategory" + +_TypeCategory_primitive = Model.Name "primitive" + +_TypeCategory_objectIdType = Model.Name "objectIdType" + +_TypeCategory_enum = Model.Name "enum" + +_TypeCategory_struct = Model.Name "struct" + +_TypeCategory_classification = Model.Name "classification" + +_TypeCategory_entity = Model.Name "entity" + +_TypeCategory_array = Model.Name "array" + +_TypeCategory_map = Model.Name "map" + +_TypeCategory_relationship = Model.Name "relationship" + +_TypeCategory_businessMetadata = Model.Name "businessMetadata" diff --git a/src/main/haskell/Hydra/Ext/Avro/Coder.hs b/src/main/haskell/Hydra/Ext/Avro/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Coder.hs @@ -0,0 +1,663 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Avro-to-Hydra adapter for converting Avro schemas and data to Hydra types and terms + +module Hydra.Ext.Avro.Coder where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Avro.Environment as Environment +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Annotate an adapter's target type with optional annotations +annotateAdapter :: Maybe (M.Map Model.Name Model.Term) -> Coders.Adapter t0 Model.Type t1 t2 t3 -> Coders.Adapter t0 Model.Type t1 t2 t3 +annotateAdapter ann ad = + Optionals.match ann ad (\n -> Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad), + Coders.adapterSource = (Coders.adapterSource ad), + Coders.adapterTarget = (Model.TypeAnnotated (Model.AnnotatedType { + Model.annotatedTypeBody = (Coders.adapterTarget ad), + Model.annotatedTypeAnnotation = (Model.TermMap (Maps.mapKeys (\n2 -> Model.TermVariable n2) n))})), + Coders.adapterCoder = (Coders.adapterCoder ad)}) + +-- | The annotation key for foreign key metadata on an Avro field +avroForeignKey :: String +avroForeignKey = "@foreignKey" + +-- | Create an adapter between Avro schemas and Hydra types/terms +avroHydraAdapter :: t0 -> Schema.Schema -> Environment.AvroEnvironment -> Either Errors.Error (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error, Environment.AvroEnvironment) +avroHydraAdapter cx schema env0 = + + let simpleAdapter = + \env -> \typ -> \encode -> \decode -> Right ( + Coders.Adapter { + Coders.adapterIsLossy = False, + Coders.adapterSource = schema, + Coders.adapterTarget = typ, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encode, + Coders.coderDecode = decode}}, + env) + doubleToInt = \d -> Literals.bigintToInt32 (Literals.decimalToBigint d) + doubleToLong = \d -> Literals.bigintToInt64 (Literals.decimalToBigint d) + in case schema of + Schema.SchemaArray v0 -> Eithers.bind (avroHydraAdapter cx (Schema.arrayItems v0) env0) (\adEnv -> + let ad = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad), + Coders.adapterSource = schema, + Coders.adapterTarget = (Model.TypeList (Coders.adapterTarget ad)), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\v -> case v of + JsonModel.ValueArray v1 -> Eithers.map (\ts -> Model.TermList ts) (Eithers.mapList (\jv -> Coders.coderEncode (Coders.adapterCoder ad) jv) v1)), + Coders.coderDecode = (\t -> case t of + Model.TermList v1 -> Eithers.map (\jvs -> JsonModel.ValueArray jvs) (Eithers.mapList (\tv -> Coders.coderDecode (Coders.adapterCoder ad) tv) v1))}}, + env1))) + Schema.SchemaMap v0 -> Eithers.bind (avroHydraAdapter cx (Schema.mapValues v0) env0) (\adEnv -> + let ad = Pairs.first adEnv + env1 = Pairs.second adEnv + pairToHydra = + \entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Eithers.map (\v_ -> (Model.TermLiteral (Model.LiteralString k), v_)) (Coders.coderEncode (Coders.adapterCoder ad) v)) + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad), + Coders.adapterSource = schema, + Coders.adapterTarget = (Model.TypeMap (Model.MapType { + Model.mapTypeKeys = (Model.TypeLiteral Model.LiteralTypeString), + Model.mapTypeValues = (Coders.adapterTarget ad)})), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\v -> case v of + JsonModel.ValueObject v1 -> Eithers.map (\pairs -> Model.TermMap (Maps.fromList pairs)) (Eithers.mapList (\e -> pairToHydra e) v1)), + Coders.coderDecode = (\m -> Eithers.map (\mp_ -> JsonModel.ValueObject (Maps.toList mp_)) (ExtractModel.map (\t -> ExtractModel.string (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t) (\t -> Coders.coderDecode (Coders.adapterCoder ad) t) (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) m))}}, + env1))) + Schema.SchemaNamed v0 -> + let ns = Schema.namedNamespace v0 + manns = namedAnnotationsToCore v0 + ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) + lastNs = Environment.avroEnvironmentNamespace env0 + nextNs = Optionals.match ns lastNs (\s -> Just s) + env1 = + Environment.AvroEnvironment { + Environment.avroEnvironmentNamedAdapters = (Environment.avroEnvironmentNamedAdapters env0), + Environment.avroEnvironmentNamespace = nextNs, + Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env0)} + qname = + Environment.AvroQualifiedName { + Environment.avroQualifiedNameNamespace = nextNs, + Environment.avroQualifiedNameName = (Schema.namedName v0)} + hydraName = avroNameToHydraName qname + in (Optionals.match (getAvroHydraAdapter qname env1) (Eithers.bind (case (Schema.namedType v0) of + Schema.NamedTypeEnum v1 -> + let syms = Schema.enumSymbols v1 + typ = + Model.TypeUnion (Lists.map (\s -> Model.FieldType { + Model.fieldTypeName = (Model.Name s), + Model.fieldTypeType = Model.TypeUnit}) syms) + in (simpleAdapter env1 typ (\jv -> case jv of + JsonModel.ValueString v2 -> Right (Model.TermInject (Model.Injection { + Model.injectionTypeName = hydraName, + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name v2), + Model.fieldTerm = Model.TermUnit}}))) (\t -> case t of + Model.TermInject v2 -> + let fld = Model.injectionField v2 + fn = Model.fieldName fld + in (Right (JsonModel.ValueString (Model.unName fn))))) + Schema.NamedTypeFixed _ -> simpleAdapter env1 (Model.TypeLiteral Model.LiteralTypeBinary) (\jv -> case jv of + JsonModel.ValueString v2 -> Right (Model.TermLiteral (Model.LiteralBinary (Literals.base64ToBinary v2)))) (\t -> Eithers.map (\b -> JsonModel.ValueString (Literals.binaryToBase64 b)) (ExtractModel.binary (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.NamedTypeRecord v1 -> + let avroFields = Schema.recordFields v1 + in (Eithers.bind (prepareFields cx env1 avroFields) (\prepResult -> + let adaptersByFieldName = Pairs.first prepResult + env2 = Pairs.second prepResult + in (Eithers.bind (findAvroPrimaryKeyField cx qname avroFields) (\pk -> + let encodePair = + \entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Optionals.match (Maps.lookup k adaptersByFieldName) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "unrecognized field for ", + (showQname qname), + ": ", + k])))) (\fad -> Eithers.map (\v_ -> Model.Field { + Model.fieldName = (Model.Name k), + Model.fieldTerm = v_}) (Coders.coderEncode (Coders.adapterCoder (Pairs.second fad)) v))) + decodeField = + \fld -> + let k = Model.unName (Model.fieldName fld) + v = Model.fieldTerm fld + in (Optionals.match (Maps.lookup k adaptersByFieldName) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "unrecognized field for ", + (showQname qname), + ": ", + k])))) (\fad -> Eithers.map (\v_ -> (k, v_)) (Coders.coderDecode (Coders.adapterCoder (Pairs.second fad)) v))) + lossy = + Lists.foldl (\b -> \fad -> Logic.or b (Coders.adapterIsLossy (Pairs.second fad))) False (Maps.elems adaptersByFieldName) + hfields = + Lists.map (\fad -> Model.FieldType { + Model.fieldTypeName = (Model.Name (Schema.fieldName (Pairs.first fad))), + Model.fieldTypeType = (Coders.adapterTarget (Pairs.second fad))}) (Maps.elems adaptersByFieldName) + target = Model.TypeRecord hfields + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = schema, + Coders.adapterTarget = target, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\jv -> case jv of + JsonModel.ValueObject v2 -> Eithers.map (\fields -> Model.TermRecord (Model.Record { + Model.recordTypeName = hydraName, + Model.recordFields = fields})) (Eithers.mapList (\e -> encodePair e) v2)), + Coders.coderDecode = (\t -> case t of + Model.TermRecord v2 -> Eithers.map (\kvs -> JsonModel.ValueObject kvs) (Eithers.mapList (\fld -> decodeField fld) (Model.recordFields v2)))}}, + env2))))))) (\adEnv2 -> + let ad = Pairs.first adEnv2 + env2 = Pairs.second adEnv2 + env3 = putAvroHydraAdapter qname ad env2 + env4 = + Environment.AvroEnvironment { + Environment.avroEnvironmentNamedAdapters = (Environment.avroEnvironmentNamedAdapters env3), + Environment.avroEnvironmentNamespace = lastNs, + Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env3)} + in (Right (annotateAdapter ann ad, env4)))) (\_ad -> err cx (Strings.concat2 "Avro named type defined more than once: " (showQname qname)))) + Schema.SchemaPrimitive v0 -> case v0 of + Schema.PrimitiveNull -> simpleAdapter env0 Model.TypeUnit (\jv -> case jv of + JsonModel.ValueString v2 -> Right (Model.TermLiteral (Model.LiteralString v2))) (\t -> Eithers.map (\s -> JsonModel.ValueString s) (ExtractModel.string (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveBoolean -> simpleAdapter env0 (Model.TypeLiteral Model.LiteralTypeBoolean) (\jv -> case jv of + JsonModel.ValueBoolean v2 -> Right (Model.TermLiteral (Model.LiteralBoolean v2))) (\t -> Eithers.map (\b -> JsonModel.ValueBoolean b) (ExtractModel.boolean (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveInt -> simpleAdapter env0 (Model.TypeLiteral (Model.LiteralTypeInteger Model.IntegerTypeInt32)) (\jv -> case jv of + JsonModel.ValueNumber v2 -> Right (Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 (doubleToInt v2))))) (\t -> Eithers.map (\i -> JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint i))) (ExtractModel.int32 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveLong -> simpleAdapter env0 (Model.TypeLiteral (Model.LiteralTypeInteger Model.IntegerTypeInt64)) (\jv -> case jv of + JsonModel.ValueNumber v2 -> Right (Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt64 (doubleToLong v2))))) (\t -> Eithers.map (\i -> JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int64ToBigint i))) (ExtractModel.int64 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveFloat -> simpleAdapter env0 (Model.TypeLiteral (Model.LiteralTypeFloat Model.FloatTypeFloat32)) (\jv -> case jv of + JsonModel.ValueNumber v2 -> Right (Model.TermLiteral (Model.LiteralFloat (Model.FloatValueFloat32 (Literals.decimalToFloat32 v2))))) (\t -> Eithers.map (\f -> JsonModel.ValueNumber (Literals.float32ToDecimal f)) (ExtractModel.float32 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveDouble -> simpleAdapter env0 (Model.TypeLiteral (Model.LiteralTypeFloat Model.FloatTypeFloat64)) (\jv -> case jv of + JsonModel.ValueNumber v2 -> Right (Model.TermLiteral (Model.LiteralFloat (Model.FloatValueFloat64 (Literals.decimalToFloat64 v2))))) (\t -> Eithers.map (\d -> JsonModel.ValueNumber (Literals.float64ToDecimal d)) (ExtractModel.float64 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveBytes -> simpleAdapter env0 (Model.TypeLiteral Model.LiteralTypeBinary) (\jv -> case jv of + JsonModel.ValueString v2 -> Right (Model.TermLiteral (Model.LiteralBinary (Literals.base64ToBinary v2)))) (\t -> Eithers.map (\b -> JsonModel.ValueString (Literals.binaryToBase64 b)) (ExtractModel.binary (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.PrimitiveString -> simpleAdapter env0 (Model.TypeLiteral Model.LiteralTypeString) (\jv -> case jv of + JsonModel.ValueString v2 -> Right (Model.TermLiteral (Model.LiteralString v2))) (\t -> Eithers.map (\s -> JsonModel.ValueString s) (ExtractModel.string (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) + Schema.SchemaReference v0 -> + let qname = parseAvroName (Environment.avroEnvironmentNamespace env0) v0 + in (Optionals.match (getAvroHydraAdapter qname env0) (err cx (Strings.concat2 "Referenced Avro type has not been defined: " (showQname qname))) (\ad -> Right (ad, env0))) + Schema.SchemaUnion v0 -> + let schemas = Schema.unUnion v0 + isNull = + \s -> case s of + Schema.SchemaPrimitive v1 -> case v1 of + Schema.PrimitiveNull -> True + _ -> False + _ -> False + hasNull = Logic.not (Lists.isEmpty (Lists.filter isNull schemas)) + nonNulls = Lists.filter (\s -> Logic.not (isNull s)) schemas + forOptional = + \s -> Eithers.bind (avroHydraAdapter cx s env0) (\adEnv -> + let ad = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad), + Coders.adapterSource = schema, + Coders.adapterTarget = (Model.TypeOptional (Coders.adapterTarget ad)), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\v -> case v of + JsonModel.ValueNull -> Right (Model.TermOptional Nothing) + _ -> Eithers.map (\t -> Model.TermOptional (Just t)) (Coders.coderEncode (Coders.adapterCoder ad) v)), + Coders.coderDecode = (\t -> case t of + Model.TermOptional v1 -> Optionals.match v1 (Right JsonModel.ValueNull) (\term_ -> Coders.coderDecode (Coders.adapterCoder ad) term_))}}, + env1))) + in (Logic.ifElse (Ordering.gt (Lists.length nonNulls) 1) (err cx "general-purpose unions are not yet supported") (Optionals.match (Lists.head nonNulls) (err cx "cannot generate the empty type") (\nonNullHead -> Logic.ifElse hasNull (forOptional nonNullHead) (Eithers.bind (avroHydraAdapter cx nonNullHead env0) (\adEnv -> + let ad = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad), + Coders.adapterSource = schema, + Coders.adapterTarget = (Coders.adapterTarget ad), + Coders.adapterCoder = (Coders.adapterCoder ad)}, + env1))))))) + +-- | Convert an Avro qualified name to a Hydra name +avroNameToHydraName :: Environment.AvroQualifiedName -> Model.Name +avroNameToHydraName qname = + + let mns = Environment.avroQualifiedNameNamespace qname + local = Environment.avroQualifiedNameName qname + in (Names.unqualifyName (Util.QualifiedName { + Util.qualifiedNameModuleName = (Optionals.map (\s -> Packaging.ModuleName s) mns), + Util.qualifiedNameLocal = local})) + +-- | The annotation key for primary key metadata on an Avro field +avroPrimaryKey :: String +avroPrimaryKey = "@primaryKey" + +-- | An empty Avro environment with no named adapters, no namespace, and no elements +emptyAvroEnvironment :: Environment.AvroEnvironment +emptyAvroEnvironment = + Environment.AvroEnvironment { + Environment.avroEnvironmentNamedAdapters = Maps.empty, + Environment.avroEnvironmentNamespace = Nothing, + Environment.avroEnvironmentElements = Maps.empty} + +-- | Encode a JSON value as a Hydra term for annotation purposes +encodeAnnotationValue :: JsonModel.Value -> Model.Term +encodeAnnotationValue v = + case v of + JsonModel.ValueArray v0 -> Model.TermList (Lists.map encodeAnnotationValue v0) + JsonModel.ValueBoolean v0 -> Model.TermLiteral (Model.LiteralBoolean v0) + JsonModel.ValueNull -> Model.TermUnit + JsonModel.ValueNumber v0 -> Model.TermLiteral (Model.LiteralDecimal v0) + JsonModel.ValueObject v0 -> Model.TermMap (Maps.fromList (Lists.map (\entry -> + let k = Pairs.first entry + v_ = Pairs.second entry + in (Model.TermLiteral (Model.LiteralString k), (encodeAnnotationValue v_))) v0)) + JsonModel.ValueString v0 -> Model.TermLiteral (Model.LiteralString v0) + +-- | Construct an error result with a message in context +err :: t0 -> String -> Either Errors.Error t1 +err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) + +-- | Extract a JSON array or return an error +expectArrayE :: t0 -> JsonModel.Value -> Either t1 [JsonModel.Value] +expectArrayE cx value = + case value of + JsonModel.ValueArray v0 -> Right v0 + +-- | Extract a JSON object or return an error +expectObjectE :: t0 -> JsonModel.Value -> Either t1 (M.Map String JsonModel.Value) +expectObjectE cx value = + case value of + JsonModel.ValueObject v0 -> Right (Maps.fromList v0) + +-- | Extract a JSON string or return an error +expectStringE :: t0 -> JsonModel.Value -> Either t1 String +expectStringE cx value = + case value of + JsonModel.ValueString v0 -> Right v0 + +-- | Extract field annotations and convert them to core Name/Term pairs +fieldAnnotationsToCore :: Schema.Field -> M.Map Model.Name Model.Term +fieldAnnotationsToCore f = + Maps.fromList (Lists.map (\entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Model.Name k, (encodeAnnotationValue v))) (Maps.toList (Schema.fieldAnnotations f))) + +-- | Find the primary key field among a list of Avro fields +findAvroPrimaryKeyField :: t0 -> Environment.AvroQualifiedName -> [Schema.Field] -> Either Errors.Error (Maybe Environment.AvroPrimaryKey) +findAvroPrimaryKeyField cx qname avroFields = + + let keys = Optionals.givens (Lists.map (\f -> primaryKeyE cx f) avroFields) + in (Logic.ifElse (Lists.isEmpty keys) (Right Nothing) (Logic.ifElse (Equality.equal (Lists.length keys) 1) (Right (Lists.head keys)) (err cx (Strings.concat2 "multiple primary key fields for " (showQname qname))))) + +-- | Extract a foreign key annotation from a field, if present +foreignKeyE :: t0 -> Schema.Field -> Either Errors.Error (Maybe Environment.AvroForeignKey) +foreignKeyE cx f = + Optionals.match (Maps.lookup avroForeignKey (Schema.fieldAnnotations f)) (Right Nothing) (\v -> Eithers.bind (expectObjectE cx v) (\m -> Eithers.bind (Eithers.map (\s -> Model.Name s) (requireStringE cx "type" m)) (\tname -> Eithers.bind (optStringE cx "pattern" m) (\pattern_ -> + let constr = Optionals.match pattern_ (\s -> Model.Name s) (\pat -> patternToNameConstructor pat) + in (Right (Just (Environment.AvroForeignKey { + Environment.avroForeignKeyTypeName = tname, + Environment.avroForeignKeyConstructor = constr}))))))) + +-- | Look up an adapter by qualified name in the environment +getAvroHydraAdapter :: Environment.AvroQualifiedName -> Environment.AvroEnvironment -> Maybe (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error) +getAvroHydraAdapter qname env = Maps.lookup qname (Environment.avroEnvironmentNamedAdapters env) + +-- | Convert a JSON value to a string, supporting booleans, strings, and numbers +jsonToStringE :: t0 -> JsonModel.Value -> Either Errors.Error String +jsonToStringE cx v = + case v of + JsonModel.ValueBoolean v0 -> Right (Logic.ifElse v0 "true" "false") + JsonModel.ValueString v0 -> Right v0 + JsonModel.ValueNumber v0 -> Right (Literals.printDecimal v0) + _ -> unexpectedE cx "string, number, or boolean" "other" + +-- | Extract named type annotations and convert them to core Name/Term pairs +namedAnnotationsToCore :: Schema.Named -> M.Map Model.Name Model.Term +namedAnnotationsToCore n = + Maps.fromList (Lists.map (\entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Model.Name k, (encodeAnnotationValue v))) (Maps.toList (Schema.namedAnnotations n))) + +-- | Look up an optional string attribute in a JSON object map +optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 JsonModel.Value -> Either t2 (Maybe String)) +optStringE cx fname m = + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) + +-- | Parse a dotted Avro name into a qualified name +parseAvroName :: Maybe String -> String -> Environment.AvroQualifiedName +parseAvroName mns name_ = + + let parts = Strings.splitOn "." name_ + local = Optionals.withDefault name_ (Lists.last parts) + in (Logic.ifElse (Equality.equal (Lists.length parts) 1) (Environment.AvroQualifiedName { + Environment.avroQualifiedNameNamespace = mns, + Environment.avroQualifiedNameName = local}) (Environment.AvroQualifiedName { + Environment.avroQualifiedNameNamespace = (Optionals.map (\ps -> Strings.join "." ps) (Lists.init parts)), + Environment.avroQualifiedNameName = local})) + +-- | Create a name constructor from a pattern string +patternToNameConstructor :: String -> String -> Model.Name +patternToNameConstructor pat s = Model.Name (Strings.join s (Strings.splitOn "${}" pat)) + +-- | Prepare a single field, producing an adapter and updated environment +prepareField :: t0 -> Environment.AvroEnvironment -> Schema.Field -> Either Errors.Error ( + (String, (Schema.Field, (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error))), + Environment.AvroEnvironment) +prepareField cx env f = + + let manns = fieldAnnotationsToCore f + ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) + in (Eithers.bind (foreignKeyE cx f) (\fk -> Eithers.bind (Optionals.match fk (avroHydraAdapter cx (Schema.fieldType f) env) (\fkVal -> + let fkName = Environment.avroForeignKeyTypeName fkVal + fkConstr = Environment.avroForeignKeyConstructor fkVal + in (Eithers.bind (avroHydraAdapter cx (Schema.fieldType f) env) (\adEnvPair -> + let ad0 = Pairs.first adEnvPair + env1 = Pairs.second adEnvPair + elTyp = Model.TypeVariable fkName + encodeValue = + \v -> Eithers.bind (Coders.coderEncode (Coders.adapterCoder ad0) v) (\encoded -> Eithers.bind (termToStringE cx encoded) (\s -> Right (Model.TermVariable (fkConstr s)))) + decodeTerm = + \t -> case t of + Model.TermVariable v0 -> Eithers.bind (stringToTermE cx (Coders.adapterTarget ad0) (Model.unName v0)) (\term_ -> Coders.coderDecode (Coders.adapterCoder ad0) term_) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected variable")) + forTypeAndCoder = + \env2 -> \ad1 -> \typ -> \cdr -> Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy ad1), + Coders.adapterSource = (Schema.fieldType f), + Coders.adapterTarget = typ, + Coders.adapterCoder = cdr}, + env2) + in case (Strip.deannotateType (Coders.adapterTarget ad0)) of + Model.TypeOptional v0 -> case v0 of + Model.TypeLiteral _ -> forTypeAndCoder env1 ad0 (Model.TypeOptional elTyp) (Coders.Coder { + Coders.coderEncode = (\json -> Eithers.map (\v_ -> Model.TermOptional (Just v_)) (encodeValue json)), + Coders.coderDecode = decodeTerm}) + _ -> err cx "expected literal type inside optional foreign key" + Model.TypeList v0 -> case v0 of + Model.TypeLiteral _ -> forTypeAndCoder env1 ad0 (Model.TypeList elTyp) (Coders.Coder { + Coders.coderEncode = (\json -> case json of + JsonModel.ValueArray v2 -> Eithers.map (\terms -> Model.TermList terms) (Eithers.mapList (\jv -> encodeValue jv) v2) + _ -> Left (Errors.ErrorOther (Errors.OtherError "Expected JSON array"))), + Coders.coderDecode = decodeTerm}) + _ -> err cx "expected literal type inside list foreign key" + Model.TypeLiteral _ -> forTypeAndCoder env1 ad0 elTyp (Coders.Coder { + Coders.coderEncode = encodeValue, + Coders.coderDecode = decodeTerm}) + _ -> err cx (Strings.concat2 "unsupported type annotated as foreign key: " "unknown"))))) (\adEnv -> + let ad = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ((Schema.fieldName f, (f, (annotateAdapter ann ad))), env1))))) + +-- | Thread AvroEnvironment through preparing multiple fields +prepareFields :: t0 -> Environment.AvroEnvironment -> [Schema.Field] -> Either Errors.Error ( + M.Map String (Schema.Field, (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error)), + Environment.AvroEnvironment) +prepareFields cx env fields = + Lists.foldl (\acc -> \f -> Eithers.bind acc (\accPair -> + let m = Pairs.first accPair + env1 = Pairs.second accPair + in (Eithers.bind (prepareField cx env1 f) (\result -> + let kv = Pairs.first result + env2 = Pairs.second result + k = Pairs.first kv + v = Pairs.second kv + in (Right (Maps.insert k v m, env2)))))) (Right (Maps.empty, env)) fields + +-- | Extract a primary key annotation from a field, if present +primaryKeyE :: t0 -> Schema.Field -> Maybe Environment.AvroPrimaryKey +primaryKeyE cx f = + Optionals.match (Maps.lookup avroPrimaryKey (Schema.fieldAnnotations f)) Nothing (\v -> Eithers.either (\_ -> Nothing) (\s -> Just (Environment.AvroPrimaryKey { + Environment.avroPrimaryKeyFieldName = (Model.Name (Schema.fieldName f)), + Environment.avroPrimaryKeyConstructor = (patternToNameConstructor s)})) (expectStringE cx v)) + +-- | Store an adapter in the environment by qualified name +putAvroHydraAdapter :: Environment.AvroQualifiedName -> Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error -> Environment.AvroEnvironment -> Environment.AvroEnvironment +putAvroHydraAdapter qname ad env = + Environment.AvroEnvironment { + Environment.avroEnvironmentNamedAdapters = (Maps.insert qname ad (Environment.avroEnvironmentNamedAdapters env)), + Environment.avroEnvironmentNamespace = (Environment.avroEnvironmentNamespace env), + Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env)} + +-- | Look up a required string attribute in a JSON object map +requireStringE :: t0 -> String -> M.Map String JsonModel.Value -> Either Errors.Error String +requireStringE cx fname m = + Optionals.match (Maps.lookup fname m) (err cx (Strings.concat [ + "required attribute ", + (Literals.printString fname), + " not found"])) (\v -> expectStringE cx v) + +-- | Recursively rewrite an Avro schema using a monadic transformation function +rewriteAvroSchemaM :: ((Schema.Schema -> Either t0 Schema.Schema) -> Schema.Schema -> Either t0 Schema.Schema) -> Schema.Schema -> Either t0 Schema.Schema +rewriteAvroSchemaM f schema = + + let recurse = rewriteAvroSchemaM f + fsub = + \s -> case s of + Schema.SchemaArray v0 -> Eithers.map (\els_ -> Schema.SchemaArray (Schema.Array { + Schema.arrayItems = els_})) (recurse (Schema.arrayItems v0)) + Schema.SchemaMap v0 -> Eithers.map (\vs_ -> Schema.SchemaMap (Schema.Map { + Schema.mapValues = vs_})) (recurse (Schema.mapValues v0)) + Schema.SchemaNamed v0 -> Eithers.map (\nt_ -> Schema.SchemaNamed (Schema.Named { + Schema.namedName = (Schema.namedName v0), + Schema.namedNamespace = (Schema.namedNamespace v0), + Schema.namedAliases = (Schema.namedAliases v0), + Schema.namedDoc = (Schema.namedDoc v0), + Schema.namedType = nt_, + Schema.namedAnnotations = (Schema.namedAnnotations v0)})) (case (Schema.namedType v0) of + Schema.NamedTypeRecord v1 -> Eithers.map (\fields_ -> Schema.NamedTypeRecord (Schema.Record { + Schema.recordFields = fields_})) (Eithers.mapList (\fld -> Eithers.map (\t_ -> Schema.Field { + Schema.fieldName = (Schema.fieldName fld), + Schema.fieldDoc = (Schema.fieldDoc fld), + Schema.fieldType = t_, + Schema.fieldDefault = (Schema.fieldDefault fld), + Schema.fieldOrder = (Schema.fieldOrder fld), + Schema.fieldAliases = (Schema.fieldAliases fld), + Schema.fieldAnnotations = (Schema.fieldAnnotations fld)}) (recurse (Schema.fieldType fld))) (Schema.recordFields v1)) + _ -> Right (Schema.namedType v0)) + Schema.SchemaUnion v0 -> Eithers.map (\schemas_ -> Schema.SchemaUnion (Schema.Union schemas_)) (Eithers.mapList (\us -> recurse us) (Schema.unUnion v0)) + _ -> Right s + in (f fsub schema) + +-- | Convert an Avro qualified name to a display string +showQname :: Environment.AvroQualifiedName -> String +showQname qname = + + let mns = Environment.avroQualifiedNameNamespace qname + local = Environment.avroQualifiedNameName qname + in (Strings.concat2 (Optionals.match mns "" (\ns -> Strings.concat2 ns ".")) local) + +-- | Parse a string into a term of the expected type +stringToTermE :: t0 -> Model.Type -> String -> Either Errors.Error Model.Term +stringToTermE cx typ s = + + let readErr = err cx "failed to read value" + readAndWrap = \reader -> \wrapper -> Optionals.match (reader s) readErr (\v -> Right (Model.TermLiteral (wrapper v))) + in case (Strip.deannotateType typ) of + Model.TypeLiteral v0 -> case v0 of + Model.LiteralTypeBoolean -> readAndWrap (\x -> Literals.parseBoolean x) (\b -> Model.LiteralBoolean b) + Model.LiteralTypeInteger v1 -> case v1 of + Model.IntegerTypeBigint -> readAndWrap (\x -> Literals.parseBigint x) (\i -> Model.LiteralInteger (Model.IntegerValueBigint i)) + Model.IntegerTypeInt8 -> readAndWrap (\x -> Literals.parseInt8 x) (\i -> Model.LiteralInteger (Model.IntegerValueInt8 i)) + Model.IntegerTypeInt16 -> readAndWrap (\x -> Literals.parseInt16 x) (\i -> Model.LiteralInteger (Model.IntegerValueInt16 i)) + Model.IntegerTypeInt32 -> readAndWrap (\x -> Literals.parseInt32 x) (\i -> Model.LiteralInteger (Model.IntegerValueInt32 i)) + Model.IntegerTypeInt64 -> readAndWrap (\x -> Literals.parseInt64 x) (\i -> Model.LiteralInteger (Model.IntegerValueInt64 i)) + Model.IntegerTypeUint8 -> readAndWrap (\x -> Literals.parseUint8 x) (\i -> Model.LiteralInteger (Model.IntegerValueUint8 i)) + Model.IntegerTypeUint16 -> readAndWrap (\x -> Literals.parseUint16 x) (\i -> Model.LiteralInteger (Model.IntegerValueUint16 i)) + Model.IntegerTypeUint32 -> readAndWrap (\x -> Literals.parseUint32 x) (\i -> Model.LiteralInteger (Model.IntegerValueUint32 i)) + Model.IntegerTypeUint64 -> readAndWrap (\x -> Literals.parseUint64 x) (\i -> Model.LiteralInteger (Model.IntegerValueUint64 i)) + Model.LiteralTypeString -> Right (Model.TermLiteral (Model.LiteralString s)) + _ -> unexpectedE cx "literal type" "other literal type" + _ -> unexpectedE cx "literal type" "other" + +-- | Convert a literal term to its string representation +termToStringE :: t0 -> Model.Term -> Either Errors.Error String +termToStringE cx term = + case (Strip.deannotateTerm term) of + Model.TermLiteral v0 -> case v0 of + Model.LiteralBoolean v1 -> Right (Literals.printBoolean v1) + Model.LiteralInteger v1 -> Right (case v1 of + Model.IntegerValueBigint v2 -> Literals.printBigint v2 + Model.IntegerValueInt8 v2 -> Literals.printInt8 v2 + Model.IntegerValueInt16 v2 -> Literals.printInt16 v2 + Model.IntegerValueInt32 v2 -> Literals.printInt32 v2 + Model.IntegerValueInt64 v2 -> Literals.printInt64 v2 + Model.IntegerValueUint8 v2 -> Literals.printUint8 v2 + Model.IntegerValueUint16 v2 -> Literals.printUint16 v2 + Model.IntegerValueUint32 v2 -> Literals.printUint32 v2 + Model.IntegerValueUint64 v2 -> Literals.printUint64 v2) + Model.LiteralString v1 -> Right v1 + _ -> unexpectedE cx "boolean, integer, or string" "other literal" + Model.TermOptional v0 -> Optionals.match v0 (unexpectedE cx "literal value" "Nothing") (\term_ -> termToStringE cx term_) + _ -> unexpectedE cx "literal value" "other" + +-- | Construct an error for unexpected values +unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 +unexpectedE cx expected found = + err cx (Strings.concat [ + "Expected ", + expected, + ", found: ", + found]) diff --git a/src/main/haskell/Hydra/Ext/Avro/Encoder.hs b/src/main/haskell/Hydra/Ext/Avro/Encoder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Encoder.hs @@ -0,0 +1,607 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Hydra-to-Avro encoder: converts Hydra types and terms to Avro schemas and JSON values + +module Hydra.Ext.Avro.Encoder where + +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Avro.Environment as Environment +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Build an Avro field from a name-adapter pair +buildAvroField :: (Model.Name, (Coders.Adapter t0 Schema.Schema t1 t2 t3)) -> Schema.Field +buildAvroField nameAd = + + let name_ = Pairs.first nameAd + ad = Pairs.second nameAd + in Schema.Field { + Schema.fieldName = (localName name_), + Schema.fieldDoc = Nothing, + Schema.fieldType = (Coders.adapterTarget ad), + Schema.fieldDefault = Nothing, + Schema.fieldOrder = Nothing, + Schema.fieldAliases = Nothing, + Schema.fieldAnnotations = Maps.empty} + +-- | Create an empty encode environment with the given type map +emptyEncodeEnvironment :: M.Map Model.Name Model.Type -> Environment.EncodeEnvironment +emptyEncodeEnvironment typeMap = + Environment.EncodeEnvironment { + Environment.encodeEnvironmentTypeMap = typeMap, + Environment.encodeEnvironmentEmitted = Maps.empty} + +-- | Encode a Hydra type to an Avro schema adapter, given the type map and a root name +encodeType :: t0 -> M.Map Model.Name Model.Type -> Model.Name -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error) +encodeType cx typeMap name_ = + Eithers.map (\adEnv -> Pairs.first adEnv) (encodeTypeWithEnv cx name_ (emptyEncodeEnvironment typeMap)) + +-- | Core encoding logic: recursively encode a Hydra type to an Avro schema +encodeTypeInner :: t0 -> Maybe Model.Name -> Model.Type -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error, Environment.EncodeEnvironment) +encodeTypeInner cx mName typ env = + + let annResult = extractAnnotations typ + annotations = Pairs.first annResult + bareType = Pairs.second annResult + simpleAdapter = + \target -> \lossy -> \encode -> \decode -> Right ( + Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = typ, + Coders.adapterTarget = target, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encode, + Coders.coderDecode = decode}}, + env) + in case bareType of + Model.TypeUnit -> simpleAdapter (Schema.SchemaPrimitive Schema.PrimitiveNull) False (\_t -> Right JsonModel.ValueNull) (\_j -> Right Model.TermUnit) + Model.TypeLiteral v0 -> Eithers.map (\ad -> (ad, env)) (literalAdapter cx typ v0) + Model.TypeList v0 -> Eithers.bind (encodeTypeInner cx Nothing v0 env) (\adEnv -> + let innerAd = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy innerAd), + Coders.adapterSource = typ, + Coders.adapterTarget = (Schema.SchemaArray (Schema.Array { + Schema.arrayItems = (Coders.adapterTarget innerAd)})), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\t -> case t of + Model.TermList v1 -> Eithers.map (\jvs -> JsonModel.ValueArray jvs) (Eithers.mapList (\el -> Coders.coderEncode (Coders.adapterCoder innerAd) el) v1)), + Coders.coderDecode = (\j -> case j of + JsonModel.ValueArray v1 -> Eithers.map (\ts -> Model.TermList ts) (Eithers.mapList (\el -> Coders.coderDecode (Coders.adapterCoder innerAd) el) v1))}}, + env1))) + Model.TypeMap v0 -> + let keyType = Model.mapTypeKeys v0 + valType = Model.mapTypeValues v0 + in case (Strip.deannotateType keyType) of + Model.TypeLiteral v1 -> case v1 of + Model.LiteralTypeString -> Eithers.bind (encodeTypeInner cx Nothing valType env) (\adEnv -> + let valAd = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy valAd), + Coders.adapterSource = typ, + Coders.adapterTarget = (Schema.SchemaMap (Schema.Map { + Schema.mapValues = (Coders.adapterTarget valAd)})), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\t -> case t of + Model.TermMap v3 -> + let encodeEntry = + \entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Eithers.bind (ExtractModel.string (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) k) (\kStr -> Eithers.map (\vJson -> (kStr, vJson)) (Coders.coderEncode (Coders.adapterCoder valAd) v))) + in (Eithers.map (\pairs -> JsonModel.ValueObject pairs) (Eithers.mapList encodeEntry (Maps.toList v3)))), + Coders.coderDecode = (\j -> case j of + JsonModel.ValueObject v3 -> + let decodeEntry = + \entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Eithers.map (\vTerm -> (Model.TermLiteral (Model.LiteralString k), vTerm)) (Coders.coderDecode (Coders.adapterCoder valAd) v)) + in (Eithers.map (\pairs -> Model.TermMap (Maps.fromList pairs)) (Eithers.mapList decodeEntry v3)))}}, + env1))) + _ -> err cx "Avro maps require string keys" + _ -> err cx "Avro maps require string keys" + Model.TypeRecord v0 -> namedTypeAdapter cx typ mName annotations v0 env (\avroFields -> Schema.NamedTypeRecord (Schema.Record { + Schema.recordFields = avroFields})) recordTermCoder + Model.TypeUnion v0 -> + let allUnit = + Lists.foldl (\b -> \ft -> Logic.and b (case (Model.fieldTypeType ft) of + Model.TypeUnit -> True + _ -> False)) True v0 + in (Logic.ifElse allUnit (enumAdapter cx typ mName annotations v0 env) (unionAsRecordAdapter cx typ mName annotations v0 env)) + Model.TypeOptional v0 -> Eithers.bind (encodeTypeInner cx Nothing v0 env) (\adEnv -> + let innerAd = Pairs.first adEnv + env1 = Pairs.second adEnv + in (Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy innerAd), + Coders.adapterSource = typ, + Coders.adapterTarget = (Schema.SchemaUnion (Schema.Union [ + Schema.SchemaPrimitive Schema.PrimitiveNull, + (Coders.adapterTarget innerAd)])), + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\t -> case t of + Model.TermOptional v1 -> Optionals.match v1 (Right JsonModel.ValueNull) (\inner -> Coders.coderEncode (Coders.adapterCoder innerAd) inner)), + Coders.coderDecode = (\j -> case j of + JsonModel.ValueNull -> Right (Model.TermOptional Nothing) + _ -> Eithers.map (\t -> Model.TermOptional (Just t)) (Coders.coderDecode (Coders.adapterCoder innerAd) j))}}, + env1))) + Model.TypeWrap v0 -> encodeTypeInner cx mName v0 env + Model.TypeVariable v0 -> Optionals.match (Maps.lookup v0 (Environment.encodeEnvironmentEmitted env)) (Optionals.match (Maps.lookup v0 (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.concat2 "referenced type not found: " (Model.unName v0))) (\refType -> encodeTypeInner cx (Just v0) refType env)) (\existingAd -> Right ( + Coders.Adapter { + Coders.adapterIsLossy = (Coders.adapterIsLossy existingAd), + Coders.adapterSource = (Coders.adapterSource existingAd), + Coders.adapterTarget = (Schema.SchemaReference (localName v0)), + Coders.adapterCoder = (Coders.adapterCoder existingAd)}, + env)) + _ -> err cx "unsupported Hydra type for Avro encoding" + +-- | Encode with full environment threading. Returns the adapter and updated environment +encodeTypeWithEnv :: t0 -> Model.Name -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error, Environment.EncodeEnvironment) +encodeTypeWithEnv cx name_ env = + Optionals.match (Maps.lookup name_ (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.concat2 "type not found in type map: " (Literals.printString (Model.unName name_)))) (\typ -> encodeTypeInner cx (Just name_) typ env) + +-- | Adapter for all-unit union types (enums) +enumAdapter :: t0 -> Model.Type -> Maybe Model.Name -> M.Map Model.Name Model.Term -> [Model.FieldType] -> Environment.EncodeEnvironment -> Either t1 (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error, Environment.EncodeEnvironment) +enumAdapter cx typ mName annotations fieldTypes env0 = + + let symbols = Lists.map (\ft -> localName (Model.fieldTypeName ft)) fieldTypes + typeName = Optionals.withDefault (typeToName typ) mName + avroAnnotations = hydraAnnotationsToAvro annotations + avroSchema = + Schema.SchemaNamed (Schema.Named { + Schema.namedName = (localName typeName), + Schema.namedNamespace = (nameNamespace typeName), + Schema.namedAliases = Nothing, + Schema.namedDoc = Nothing, + Schema.namedType = (Schema.NamedTypeEnum (Schema.Enum { + Schema.enumSymbols = symbols, + Schema.enumDefault = Nothing})), + Schema.namedAnnotations = avroAnnotations}) + adapter_ = + Coders.Adapter { + Coders.adapterIsLossy = False, + Coders.adapterSource = typ, + Coders.adapterTarget = avroSchema, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\t -> case t of + Model.TermInject v0 -> + let fname = Model.injectionField v0 + in (Right (JsonModel.ValueString (localName (Model.fieldName fname)))) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected union term for enum"))), + Coders.coderDecode = (\j -> case j of + JsonModel.ValueString v0 -> Right (Model.TermInject (Model.Injection { + Model.injectionTypeName = typeName, + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name v0), + Model.fieldTerm = Model.TermUnit}})))}} + env1 = + Environment.EncodeEnvironment { + Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env0), + Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env0))} + in (Right (adapter_, env1)) + +-- | Construct an error result with a message in context +err :: t0 -> String -> Either Errors.Error t1 +err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) + +-- | Extract annotations from a potentially annotated type +extractAnnotations :: Model.Type -> (M.Map Model.Name Model.Term, Model.Type) +extractAnnotations typ = + case typ of + Model.TypeAnnotated v0 -> + let inner = Model.annotatedTypeBody v0 + anns = Annotations.getAnnotationMap (Model.annotatedTypeAnnotation v0) + innerResult = extractAnnotations inner + innerAnns = Pairs.first innerResult + bareType = Pairs.second innerResult + in (Maps.union anns innerAnns, bareType) + _ -> (Maps.empty, typ) + +-- | Create an adapter for float types +floatAdapter :: t0 -> t1 -> Model.FloatType -> Either t2 (Coders.Adapter t1 Schema.Schema Model.Term JsonModel.Value Errors.Error) +floatAdapter cx typ ft = + + let simple = + \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = typ, + Coders.adapterTarget = target, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encode, + Coders.coderDecode = decode}}) + in case ft of + Model.FloatTypeFloat32 -> simple (Schema.SchemaPrimitive Schema.PrimitiveFloat) False (\t -> Eithers.map (\f -> JsonModel.ValueNumber (Literals.float32ToDecimal f)) (ExtractModel.float32 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of + JsonModel.ValueNumber v1 -> Right (Model.TermLiteral (Model.LiteralFloat (Model.FloatValueFloat32 (Literals.decimalToFloat32 v1))))) + Model.FloatTypeFloat64 -> simple (Schema.SchemaPrimitive Schema.PrimitiveDouble) False (\t -> Eithers.map (\d -> JsonModel.ValueNumber (Literals.float64ToDecimal d)) (ExtractModel.float64 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of + JsonModel.ValueNumber v1 -> Right (Model.TermLiteral (Model.LiteralFloat (Model.FloatValueFloat64 (Literals.decimalToFloat64 v1))))) + _ -> simple (Schema.SchemaPrimitive Schema.PrimitiveDouble) True (\t -> case t of + Model.TermLiteral v0 -> case v0 of + Model.LiteralFloat v1 -> Right (JsonModel.ValueNumber (floatValueToDouble v1))) (\j -> case j of + JsonModel.ValueNumber v0 -> Right (Model.TermLiteral (Model.LiteralFloat (Model.FloatValueFloat64 (Literals.decimalToFloat64 v0))))) + +-- | Convert any float value to a JSON decimal number +floatValueToDouble :: Model.FloatValue -> Sci.Scientific +floatValueToDouble fv = + case fv of + Model.FloatValueFloat32 v0 -> Literals.float32ToDecimal v0 + Model.FloatValueFloat64 v0 -> Literals.float64ToDecimal v0 + +-- | Fold over field types, building adapters and threading the environment +foldFieldAdapters :: t0 -> [Model.FieldType] -> Environment.EncodeEnvironment -> Either Errors.Error ( + [(Model.Name, (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error))], + Environment.EncodeEnvironment) +foldFieldAdapters cx fieldTypes env0 = + Lists.foldl (\acc -> \ft -> Eithers.bind acc (\accPair -> + let soFar = Pairs.first accPair + env1 = Pairs.second accPair + fname = Model.fieldTypeName ft + ftype = Model.fieldTypeType ft + in (Eithers.bind (encodeTypeInner cx Nothing ftype env1) (\adEnv -> + let ad = Pairs.first adEnv + env2 = Pairs.second adEnv + in (Right (Lists.concat2 soFar [ + (fname, ad)], env2)))))) (Right ([], env0)) fieldTypes + +-- | Convert Hydra annotations to Avro annotation map +hydraAnnotationsToAvro :: M.Map Model.Name Model.Term -> M.Map String JsonModel.Value +hydraAnnotationsToAvro anns = + Maps.fromList (Lists.map (\entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Model.unName k, (termToJsonValue v))) (Maps.toList anns)) + +-- | Encode a single type without a type map (for simple/anonymous types) +hydraAvroAdapter :: t0 -> M.Map Model.Name Model.Type -> Model.Type -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error) +hydraAvroAdapter cx typeMap typ = + Eithers.map (\adEnv -> Pairs.first adEnv) (encodeTypeInner cx Nothing typ (emptyEncodeEnvironment typeMap)) + +-- | Convert a Hydra Name to an Avro qualified name (local name, optional namespace) +hydraNameToAvroName :: Model.Name -> (String, (Maybe String)) +hydraNameToAvroName name_ = (localName name_, (nameNamespace name_)) + +-- | Create an adapter for integer types +integerAdapter :: t0 -> t1 -> Model.IntegerType -> Either t2 (Coders.Adapter t1 Schema.Schema Model.Term JsonModel.Value Errors.Error) +integerAdapter cx typ it = + + let simple = + \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = typ, + Coders.adapterTarget = target, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encode, + Coders.coderDecode = decode}}) + in case it of + Model.IntegerTypeInt32 -> simple (Schema.SchemaPrimitive Schema.PrimitiveInt) False (\t -> Eithers.map (\i -> JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint i))) (ExtractModel.int32 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of + JsonModel.ValueNumber v1 -> Right (Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 (Literals.bigintToInt32 (Literals.decimalToBigint v1)))))) + Model.IntegerTypeInt64 -> simple (Schema.SchemaPrimitive Schema.PrimitiveLong) False (\t -> Eithers.map (\i -> JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int64ToBigint i))) (ExtractModel.int64 (Graph.Graph { + Graph.graphBoundTerms = Maps.empty, + Graph.graphBoundTypes = Maps.empty, + Graph.graphClassConstraints = Maps.empty, + Graph.graphLambdaVariables = Sets.empty, + Graph.graphMetadata = Maps.empty, + Graph.graphPrimitives = Maps.empty, + Graph.graphSchemaTypes = Maps.empty, + Graph.graphTypeVariables = Sets.empty}) t)) (\j -> case j of + JsonModel.ValueNumber v1 -> Right (Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt64 (Literals.bigintToInt64 (Literals.decimalToBigint v1)))))) + _ -> simple (Schema.SchemaPrimitive Schema.PrimitiveLong) True (\t -> case t of + Model.TermLiteral v0 -> case v0 of + Model.LiteralInteger v1 -> Right (JsonModel.ValueNumber (integerValueToDouble v1))) (\j -> case j of + JsonModel.ValueNumber v0 -> Right (Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt64 (Literals.bigintToInt64 (Literals.decimalToBigint v0)))))) + +-- | Convert any integer value to a JSON decimal number +integerValueToDouble :: Model.IntegerValue -> Sci.Scientific +integerValueToDouble iv = + case iv of + Model.IntegerValueBigint v0 -> Literals.bigintToDecimal v0 + Model.IntegerValueInt8 v0 -> Literals.bigintToDecimal (Literals.int8ToBigint v0) + Model.IntegerValueInt16 v0 -> Literals.bigintToDecimal (Literals.int16ToBigint v0) + Model.IntegerValueInt32 v0 -> Literals.bigintToDecimal (Literals.int32ToBigint v0) + Model.IntegerValueInt64 v0 -> Literals.bigintToDecimal (Literals.int64ToBigint v0) + Model.IntegerValueUint8 v0 -> Literals.bigintToDecimal (Literals.uint8ToBigint v0) + Model.IntegerValueUint16 v0 -> Literals.bigintToDecimal (Literals.uint16ToBigint v0) + Model.IntegerValueUint32 v0 -> Literals.bigintToDecimal (Literals.uint32ToBigint v0) + Model.IntegerValueUint64 v0 -> Literals.bigintToDecimal (Literals.uint64ToBigint v0) + +-- | Create an adapter for literal types +literalAdapter :: t0 -> t1 -> Model.LiteralType -> Either t2 (Coders.Adapter t1 Schema.Schema Model.Term JsonModel.Value Errors.Error) +literalAdapter cx typ lt = + + let simple = + \target -> \lossy -> \encode -> \decode -> Right (Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = typ, + Coders.adapterTarget = target, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encode, + Coders.coderDecode = decode}}) + in case lt of + Model.LiteralTypeBoolean -> simple (Schema.SchemaPrimitive Schema.PrimitiveBoolean) False (\t -> case t of + Model.TermLiteral v1 -> case v1 of + Model.LiteralBoolean v2 -> Right (JsonModel.ValueBoolean v2)) (\j -> case j of + JsonModel.ValueBoolean v1 -> Right (Model.TermLiteral (Model.LiteralBoolean v1))) + Model.LiteralTypeString -> simple (Schema.SchemaPrimitive Schema.PrimitiveString) False (\t -> case t of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right (JsonModel.ValueString v2)) (\j -> case j of + JsonModel.ValueString v1 -> Right (Model.TermLiteral (Model.LiteralString v1))) + Model.LiteralTypeBinary -> simple (Schema.SchemaPrimitive Schema.PrimitiveBytes) False (\t -> case t of + Model.TermLiteral v1 -> case v1 of + Model.LiteralBinary v2 -> Right (JsonModel.ValueString (Literals.binaryToBase64 v2))) (\j -> case j of + JsonModel.ValueString v1 -> Right (Model.TermLiteral (Model.LiteralBinary (Literals.base64ToBinary v1)))) + Model.LiteralTypeInteger v0 -> integerAdapter cx typ v0 + Model.LiteralTypeFloat v0 -> floatAdapter cx typ v0 + +-- | Extract the local part of a qualified name +localName :: Model.Name -> String +localName name_ = + + let s = Model.unName name_ + parts = Strings.splitOn "." s + in (Optionals.withDefault s (Lists.last parts)) + +-- | Extract the namespace from a qualified name, if any +nameNamespace :: Model.Name -> Maybe String +nameNamespace name_ = + + let s = Model.unName name_ + parts = Strings.splitOn "." s + in (Logic.ifElse (Equality.equal (Lists.length parts) 1) Nothing (Optionals.map (\ps -> Strings.join "." ps) (Lists.init parts))) + +-- | Build a named type adapter (shared between record and union-as-record) +namedTypeAdapter :: t0 -> Model.Type -> Maybe Model.Name -> M.Map Model.Name Model.Term -> [Model.FieldType] -> Environment.EncodeEnvironment -> ([Schema.Field] -> Schema.NamedType) -> (t0 -> Model.Name -> [(Model.Name, (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error))] -> ((Model.Term -> Either Errors.Error JsonModel.Value), (JsonModel.Value -> Either Errors.Error Model.Term))) -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error, Environment.EncodeEnvironment) +namedTypeAdapter cx typ mName annotations fieldTypes env0 mkNamedType mkCoder = + + let typeName = Optionals.withDefault (typeToName typ) mName + in (Optionals.match (Maps.lookup typeName (Environment.encodeEnvironmentEmitted env0)) (Eithers.bind (foldFieldAdapters cx fieldTypes env0) (\faResult -> + let fieldAdapters = Pairs.first faResult + env1 = Pairs.second faResult + avroFields = Lists.map buildAvroField fieldAdapters + avroAnnotations = hydraAnnotationsToAvro annotations + avroSchema = + Schema.SchemaNamed (Schema.Named { + Schema.namedName = (localName typeName), + Schema.namedNamespace = (nameNamespace typeName), + Schema.namedAliases = Nothing, + Schema.namedDoc = Nothing, + Schema.namedType = (mkNamedType avroFields), + Schema.namedAnnotations = avroAnnotations}) + lossy = Lists.foldl (\b -> \fa -> Logic.or b (Coders.adapterIsLossy (Pairs.second fa))) False fieldAdapters + coderPair = mkCoder cx typeName fieldAdapters + encodeFn = Pairs.first coderPair + decodeFn = Pairs.second coderPair + adapter_ = + Coders.Adapter { + Coders.adapterIsLossy = lossy, + Coders.adapterSource = typ, + Coders.adapterTarget = avroSchema, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = encodeFn, + Coders.coderDecode = decodeFn}} + env2 = + Environment.EncodeEnvironment { + Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env1), + Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env1))} + in (Right (adapter_, env2)))) (\existingAd -> Right (existingAd, env0))) + +-- | Build a record term coder from field adapters +recordTermCoder :: t0 -> Model.Name -> [(Model.Name, (Coders.Adapter t1 t2 Model.Term JsonModel.Value Errors.Error))] -> ((Model.Term -> Either Errors.Error JsonModel.Value), (JsonModel.Value -> Either Errors.Error Model.Term)) +recordTermCoder cx typeName fieldAdapters = + + let encode = + \term -> case term of + Model.TermRecord v0 -> + let fields = Model.recordFields v0 + fieldMap = Maps.fromList (Lists.map (\f -> (Model.fieldName f, (Model.fieldTerm f))) fields) + encodeField = + \nameAd -> + let fname = Pairs.first nameAd + ad = Pairs.second nameAd + fTerm = Optionals.withDefault Model.TermUnit (Maps.lookup fname fieldMap) + in (Eithers.map (\jv -> (localName fname, jv)) (Coders.coderEncode (Coders.adapterCoder ad) fTerm)) + in (Eithers.map (\pairs -> JsonModel.ValueObject pairs) (Eithers.mapList encodeField fieldAdapters)) + _ -> err cx "expected record term" + decode = + \json -> case json of + JsonModel.ValueObject v0 -> + let mm = Maps.fromList v0 + decodeField = + \nameAd -> + let fname = Pairs.first nameAd + ad = Pairs.second nameAd + jv = Optionals.withDefault JsonModel.ValueNull (Maps.lookup (localName fname) mm) + in (Eithers.map (\t -> Model.Field { + Model.fieldName = fname, + Model.fieldTerm = t}) (Coders.coderDecode (Coders.adapterCoder ad) jv)) + in (Eithers.map (\fields -> Model.TermRecord (Model.Record { + Model.recordTypeName = typeName, + Model.recordFields = fields})) (Eithers.mapList decodeField fieldAdapters)) + _ -> err cx "expected JSON object" + in (encode, decode) + +-- | Convert a Hydra term to a JSON value (for annotation values) +termToJsonValue :: Model.Term -> JsonModel.Value +termToJsonValue term = + case term of + Model.TermLiteral v0 -> case v0 of + Model.LiteralString v1 -> JsonModel.ValueString v1 + Model.LiteralBoolean v1 -> JsonModel.ValueBoolean v1 + Model.LiteralInteger v1 -> JsonModel.ValueNumber (integerValueToDouble v1) + Model.LiteralFloat v1 -> JsonModel.ValueNumber (floatValueToDouble v1) + Model.LiteralBinary v1 -> JsonModel.ValueString (Literals.binaryToBase64 v1) + Model.TermList v0 -> JsonModel.ValueArray (Lists.map termToJsonValue v0) + Model.TermMap v0 -> JsonModel.ValueObject (Lists.map (\entry -> + let k = Pairs.first entry + v = Pairs.second entry + in ( + case k of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> v2 + _ -> "" + _ -> "", + (termToJsonValue v))) (Maps.toList v0)) + Model.TermRecord v0 -> Logic.ifElse (Lists.isEmpty (Model.recordFields v0)) JsonModel.ValueNull (JsonModel.ValueString "") + _ -> JsonModel.ValueString "" + +-- | Generate a default name for an anonymous type +typeToName :: Model.Type -> Model.Name +typeToName t = + case (Strip.deannotateType t) of + Model.TypeRecord _ -> Model.Name "Record" + Model.TypeUnion _ -> Model.Name "Union" + _ -> Model.Name "Unknown" + +-- | Adapter for general unions (encoded as records with optional fields) +unionAsRecordAdapter :: t0 -> Model.Type -> Maybe Model.Name -> M.Map Model.Name Model.Term -> [Model.FieldType] -> Environment.EncodeEnvironment -> Either Errors.Error (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error, Environment.EncodeEnvironment) +unionAsRecordAdapter cx typ mName annotations fieldTypes env0 = + Eithers.bind (foldFieldAdapters cx fieldTypes env0) (\faResult -> + let fieldAdapters = Pairs.first faResult + env1 = Pairs.second faResult + avroFields = + Lists.map (\nameAd -> + let fname = Pairs.first nameAd + ad = Pairs.second nameAd + in Schema.Field { + Schema.fieldName = (localName fname), + Schema.fieldDoc = Nothing, + Schema.fieldType = (Schema.SchemaUnion (Schema.Union [ + Schema.SchemaPrimitive Schema.PrimitiveNull, + (Coders.adapterTarget ad)])), + Schema.fieldDefault = (Just JsonModel.ValueNull), + Schema.fieldOrder = Nothing, + Schema.fieldAliases = Nothing, + Schema.fieldAnnotations = Maps.empty}) fieldAdapters + typeName = Optionals.withDefault (typeToName typ) mName + avroAnnotations = hydraAnnotationsToAvro annotations + avroSchema = + Schema.SchemaNamed (Schema.Named { + Schema.namedName = (localName typeName), + Schema.namedNamespace = (nameNamespace typeName), + Schema.namedAliases = Nothing, + Schema.namedDoc = Nothing, + Schema.namedType = (Schema.NamedTypeRecord (Schema.Record { + Schema.recordFields = avroFields})), + Schema.namedAnnotations = avroAnnotations}) + adapter_ = + Coders.Adapter { + Coders.adapterIsLossy = True, + Coders.adapterSource = typ, + Coders.adapterTarget = avroSchema, + Coders.adapterCoder = Coders.Coder { + Coders.coderEncode = (\t -> case t of + Model.TermInject v0 -> + let activeName = Model.fieldName (Model.injectionField v0) + activeValue = Model.fieldTerm (Model.injectionField v0) + encodePair = + \nameAd -> + let fname = Pairs.first nameAd + ad = Pairs.second nameAd + in (Logic.ifElse (Equality.equal (Model.unName fname) (Model.unName activeName)) (Eithers.map (\jv -> (localName fname, jv)) (Coders.coderEncode (Coders.adapterCoder ad) activeValue)) (Right (localName fname, JsonModel.ValueNull))) + in (Eithers.map (\pairs -> JsonModel.ValueObject pairs) (Eithers.mapList encodePair fieldAdapters)) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected union term"))), + Coders.coderDecode = (\j -> case j of + JsonModel.ValueObject v0 -> + let mm = Maps.fromList v0 + findActive = + \remaining -> Optionals.match (Lists.uncons remaining) (Left (Errors.ErrorOther (Errors.OtherError "no non-null field in union record"))) (\p -> + let head_ = Pairs.first p + rest_ = Pairs.second p + fname = Pairs.first head_ + ad = Pairs.second head_ + mjv = Maps.lookup (localName fname) mm + in (Optionals.match mjv (findActive rest_) (\jv -> case jv of + JsonModel.ValueNull -> findActive rest_ + _ -> Eithers.map (\t -> Model.TermInject (Model.Injection { + Model.injectionTypeName = typeName, + Model.injectionField = Model.Field { + Model.fieldName = fname, + Model.fieldTerm = t}})) (Coders.coderDecode (Coders.adapterCoder ad) jv)))) + in (findActive fieldAdapters) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected JSON object for union-as-record")))}} + env2 = + Environment.EncodeEnvironment { + Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env1), + Environment.encodeEnvironmentEmitted = (Maps.insert typeName adapter_ (Environment.encodeEnvironmentEmitted env1))} + in (Right (adapter_, env2))) diff --git a/src/main/haskell/Hydra/Ext/Avro/Environment.hs b/src/main/haskell/Hydra/Ext/Avro/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Environment.hs @@ -0,0 +1,90 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Type definitions for the Avro code generation environment + +module Hydra.Ext.Avro.Environment where + +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Environment for Avro-to-Hydra code generation +data AvroEnvironment = + AvroEnvironment { + -- | Named adapters for previously processed schemas + avroEnvironmentNamedAdapters :: (M.Map AvroQualifiedName (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error)), + -- | The current Avro namespace + avroEnvironmentNamespace :: (Maybe String), + -- | Generated Hydra elements + avroEnvironmentElements :: (M.Map Model.Name Model.Binding)} + +_AvroEnvironment = Model.Name "hydra.ext.avro.environment.AvroEnvironment" + +_AvroEnvironment_namedAdapters = Model.Name "namedAdapters" + +_AvroEnvironment_namespace = Model.Name "namespace" + +_AvroEnvironment_elements = Model.Name "elements" + +-- | An Avro foreign key annotation linking a field to another type +data AvroForeignKey = + AvroForeignKey { + -- | The Hydra type name referenced by this foreign key + avroForeignKeyTypeName :: Model.Name, + -- | A function which constructs element names from string values + avroForeignKeyConstructor :: (String -> Model.Name)} + +_AvroForeignKey = Model.Name "hydra.ext.avro.environment.AvroForeignKey" + +_AvroForeignKey_typeName = Model.Name "typeName" + +_AvroForeignKey_constructor = Model.Name "constructor" + +-- | An Avro primary key annotation identifying the element name field +data AvroPrimaryKey = + AvroPrimaryKey { + -- | The name of the primary key field + avroPrimaryKeyFieldName :: Model.Name, + -- | A function which constructs element names from string values + avroPrimaryKeyConstructor :: (String -> Model.Name)} + +_AvroPrimaryKey = Model.Name "hydra.ext.avro.environment.AvroPrimaryKey" + +_AvroPrimaryKey_fieldName = Model.Name "fieldName" + +_AvroPrimaryKey_constructor = Model.Name "constructor" + +-- | An Avro qualified name with optional namespace +data AvroQualifiedName = + AvroQualifiedName { + -- | The optional namespace + avroQualifiedNameNamespace :: (Maybe String), + -- | The local name + avroQualifiedNameName :: String} + deriving (Eq, Ord, Read, Show) + +_AvroQualifiedName = Model.Name "hydra.ext.avro.environment.AvroQualifiedName" + +_AvroQualifiedName_namespace = Model.Name "namespace" + +_AvroQualifiedName_name = Model.Name "name" + +-- | Environment for Hydra-to-Avro encoding, tracking which named types have been emitted +data EncodeEnvironment = + EncodeEnvironment { + -- | All named types available for reference + encodeEnvironmentTypeMap :: (M.Map Model.Name Model.Type), + -- | Adapters for types that have already been fully emitted (emit references for these) + encodeEnvironmentEmitted :: (M.Map Model.Name (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error))} + +_EncodeEnvironment = Model.Name "hydra.ext.avro.environment.EncodeEnvironment" + +_EncodeEnvironment_typeMap = Model.Name "typeMap" + +_EncodeEnvironment_emitted = Model.Name "emitted" diff --git a/src/main/haskell/Hydra/Ext/Avro/Language.hs b/src/main/haskell/Hydra/Ext/Avro/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Language.hs @@ -0,0 +1,110 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints for Apache Avro + +module Hydra.Ext.Avro.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Language constraints for Apache Avro +avroLanguage :: Coders.Language +avroLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.avro"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "avsc")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBinary, + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = + Sets.fromList [ + Model.FloatTypeFloat32, + Model.FloatTypeFloat64] + integerTypes = + Sets.fromList [ + Model.IntegerTypeInt32, + Model.IntegerTypeInt64] + termVariants = + Sets.fromList [ + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantMap, + Variants.TermVariantOptional, + Variants.TermVariantRecord] + typeVariants = + Sets.fromList [ + Variants.TypeVariantAnnotated, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantWrap, + Variants.TypeVariantOptional, + Variants.TypeVariantRecord] + typePredicate = + \typ -> case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> case (Strip.deannotateType v0) of + Model.TypeOptional _ -> False + _ -> True + _ -> True diff --git a/src/main/haskell/Hydra/Ext/Avro/Schema.hs b/src/main/haskell/Hydra/Ext/Avro/Schema.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Schema.hs @@ -0,0 +1,236 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for Avro schemas. Based on the Avro 1.11.1 specification: +-- | https://avro.apache.org/docs/1.11.1/specification + +module Hydra.Ext.Avro.Schema where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | An Avro array schema +data Array = + Array { + arrayItems :: Schema} + deriving (Eq, Ord, Read, Show) + +_Array = Model.Name "hydra.ext.avro.schema.Array" + +_Array_items = Model.Name "items" + +-- | An Avro enum schema +data Enum = + Enum { + -- | a JSON array, listing symbols, as JSON strings. All symbols in an enum must be unique; duplicates are prohibited. Every symbol must match the regular expression [A-Za-z_][A-Za-z0-9_]* (the same requirement as for names) + enumSymbols :: [String], + -- | A default value for this enumeration, used during resolution when the reader encounters a symbol from the writer that isn't defined in the reader's schema. The value provided here must be a JSON string that's a member of the symbols array + enumDefault :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_Enum = Model.Name "hydra.ext.avro.schema.Enum" + +_Enum_symbols = Model.Name "symbols" + +_Enum_default = Model.Name "default" + +-- | An Avro record field +data Field = + Field { + -- | a JSON string providing the name of the field + fieldName :: String, + -- | a JSON string describing this field for users + fieldDoc :: (Maybe String), + -- | a schema + fieldType :: Schema, + -- | default value for this field, only used when reading instances that lack the field for schema evolution purposes + fieldDefault :: (Maybe JsonModel.Value), + -- | specifies how this field impacts sort ordering of this record + fieldOrder :: (Maybe Order), + -- | a JSON array of strings, providing alternate names for this field + fieldAliases :: (Maybe [String]), + -- | Any additional key/value pairs attached to the field + fieldAnnotations :: (M.Map String JsonModel.Value)} + deriving (Eq, Ord, Read, Show) + +_Field = Model.Name "hydra.ext.avro.schema.Field" + +_Field_name = Model.Name "name" + +_Field_doc = Model.Name "doc" + +_Field_type = Model.Name "type" + +_Field_default = Model.Name "default" + +_Field_order = Model.Name "order" + +_Field_aliases = Model.Name "aliases" + +_Field_annotations = Model.Name "annotations" + +-- | An Avro fixed-size binary schema +data Fixed = + Fixed { + -- | an integer, specifying the number of bytes per value + fixedSize :: Int} + deriving (Eq, Ord, Read, Show) + +_Fixed = Model.Name "hydra.ext.avro.schema.Fixed" + +_Fixed_size = Model.Name "size" + +-- | An Avro map schema +data Map = + Map { + mapValues :: Schema} + deriving (Eq, Ord, Read, Show) + +_Map = Model.Name "hydra.ext.avro.schema.Map" + +_Map_values = Model.Name "values" + +-- | An Avro named schema: enum, fixed, or record +data Named = + Named { + -- | a string naming this schema + namedName :: String, + -- | a string that qualifies the name + namedNamespace :: (Maybe String), + -- | a JSON array of strings, providing alternate names for this schema + namedAliases :: (Maybe [String]), + -- | a JSON string providing documentation to the user of this schema + namedDoc :: (Maybe String), + namedType :: NamedType, + -- | Any additional key/value pairs attached to the type + namedAnnotations :: (M.Map String JsonModel.Value)} + deriving (Eq, Ord, Read, Show) + +_Named = Model.Name "hydra.ext.avro.schema.Named" + +_Named_name = Model.Name "name" + +_Named_namespace = Model.Name "namespace" + +_Named_aliases = Model.Name "aliases" + +_Named_doc = Model.Name "doc" + +_Named_type = Model.Name "type" + +_Named_annotations = Model.Name "annotations" + +-- | The type-specific content of an Avro named schema +data NamedType = + NamedTypeEnum Enum | + NamedTypeFixed Fixed | + NamedTypeRecord Record + deriving (Eq, Ord, Read, Show) + +_NamedType = Model.Name "hydra.ext.avro.schema.NamedType" + +_NamedType_enum = Model.Name "enum" + +_NamedType_fixed = Model.Name "fixed" + +_NamedType_record = Model.Name "record" + +-- | Specifies how a field impacts sort ordering of its enclosing record +data Order = + OrderAscending | + OrderDescending | + OrderIgnore + deriving (Eq, Ord, Read, Show) + +_Order = Model.Name "hydra.ext.avro.schema.Order" + +_Order_ascending = Model.Name "ascending" + +_Order_descending = Model.Name "descending" + +_Order_ignore = Model.Name "ignore" + +-- | An Avro primitive type +data Primitive = + -- | no value + PrimitiveNull | + -- | A binary value + PrimitiveBoolean | + -- | 32-bit signed integer + PrimitiveInt | + -- | 64-bit signed integer + PrimitiveLong | + -- | single precision (32-bit) IEEE 754 floating-point number + PrimitiveFloat | + -- | double precision (64-bit) IEEE 754 floating-point number + PrimitiveDouble | + -- | sequence of 8-bit unsigned bytes + PrimitiveBytes | + -- | unicode character sequence + PrimitiveString + deriving (Eq, Ord, Read, Show) + +_Primitive = Model.Name "hydra.ext.avro.schema.Primitive" + +_Primitive_null = Model.Name "null" + +_Primitive_boolean = Model.Name "boolean" + +_Primitive_int = Model.Name "int" + +_Primitive_long = Model.Name "long" + +_Primitive_float = Model.Name "float" + +_Primitive_double = Model.Name "double" + +_Primitive_bytes = Model.Name "bytes" + +_Primitive_string = Model.Name "string" + +-- | An Avro record schema +data Record = + Record { + -- | a JSON array, listing fields + recordFields :: [Field]} + deriving (Eq, Ord, Read, Show) + +_Record = Model.Name "hydra.ext.avro.schema.Record" + +_Record_fields = Model.Name "fields" + +-- | An Avro schema, in any of its forms +data Schema = + SchemaArray Array | + SchemaMap Map | + SchemaNamed Named | + SchemaPrimitive Primitive | + -- | A reference by name to a previously defined type + SchemaReference String | + SchemaUnion Union + deriving (Eq, Ord, Read, Show) + +_Schema = Model.Name "hydra.ext.avro.schema.Schema" + +_Schema_array = Model.Name "array" + +_Schema_map = Model.Name "map" + +_Schema_named = Model.Name "named" + +_Schema_primitive = Model.Name "primitive" + +_Schema_reference = Model.Name "reference" + +_Schema_union = Model.Name "union" + +-- | An Avro union schema: a list of alternative schemas +newtype Union = + Union { + unUnion :: [Schema]} + deriving (Eq, Ord, Read, Show) + +_Union = Model.Name "hydra.ext.avro.schema.Union" diff --git a/src/main/haskell/Hydra/Ext/Avro/SchemaJson.hs b/src/main/haskell/Hydra/Ext/Avro/SchemaJson.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/SchemaJson.hs @@ -0,0 +1,484 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | JSON serialization and deserialization for Avro schemas + +module Hydra.Ext.Avro.SchemaJson where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Json.Parser as Parser +import qualified Hydra.Core.Json.Writer as Writer +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | The JSON attribute name for the list of alternate names of a named type or field +avroAliases :: String +avroAliases = "aliases" + +-- | The JSON type-name value identifying an Avro array schema +avroArray :: String +avroArray = "array" + +-- | The JSON value identifying ascending field order +avroAscending :: String +avroAscending = "ascending" + +-- | The JSON type-name value identifying the Avro boolean primitive +avroBoolean :: String +avroBoolean = "boolean" + +-- | The JSON type-name value identifying the Avro bytes primitive +avroBytes :: String +avroBytes = "bytes" + +-- | The JSON attribute name for a field's or enum's default value +avroDefault :: String +avroDefault = "default" + +-- | The JSON value identifying descending field order +avroDescending :: String +avroDescending = "descending" + +-- | The JSON attribute name for a named type's or field's documentation string +avroDoc :: String +avroDoc = "doc" + +-- | The JSON type-name value identifying the Avro double primitive +avroDouble :: String +avroDouble = "double" + +-- | The JSON type-name value identifying an Avro enum schema +avroEnum :: String +avroEnum = "enum" + +-- | The JSON attribute name for a record's list of fields +avroFields :: String +avroFields = "fields" + +-- | The JSON type-name value identifying an Avro fixed schema +avroFixed :: String +avroFixed = "fixed" + +-- | The JSON type-name value identifying the Avro float primitive +avroFloat :: String +avroFloat = "float" + +-- | The JSON value identifying ignored field order +avroIgnore :: String +avroIgnore = "ignore" + +-- | The JSON type-name value identifying the Avro int primitive +avroInt :: String +avroInt = "int" + +-- | The JSON attribute name for an array schema's item type +avroItems :: String +avroItems = "items" + +-- | The JSON type-name value identifying the Avro long primitive +avroLong :: String +avroLong = "long" + +-- | The JSON type-name value identifying an Avro map schema +avroMap :: String +avroMap = "map" + +-- | The JSON attribute name for a named type's or field's name +avroName :: String +avroName = "name" + +-- | The JSON attribute name for a named type's namespace +avroNamespace :: String +avroNamespace = "namespace" + +-- | The JSON type-name value identifying the Avro null primitive +avroNull :: String +avroNull = "null" + +-- | The JSON attribute name for a field's sort order +avroOrder :: String +avroOrder = "order" + +-- | The JSON type-name value identifying an Avro record schema +avroRecord :: String +avroRecord = "record" + +-- | Create a coder between Avro schemas and JSON values +avroSchemaJsonCoder :: t0 -> Coders.Coder Schema.Schema JsonModel.Value Errors.Error +avroSchemaJsonCoder cx = + Coders.Coder { + Coders.coderEncode = (\schema -> Right (encodeSchema schema)), + Coders.coderDecode = (\json -> decodeSchema cx json)} + +-- | Create a coder between Avro schemas and JSON strings +avroSchemaStringCoder :: t0 -> Coders.Coder Schema.Schema String Errors.Error +avroSchemaStringCoder cx = + Coders.Coder { + Coders.coderEncode = (\schema -> Right (showJsonValue (encodeSchema schema))), + Coders.coderDecode = (\s -> Eithers.bind (Eithers.either (\e -> err cx e) (\v -> Right v) (stringToJsonValue s)) (\json -> decodeSchema cx json))} + +-- | The JSON attribute name for a fixed schema's byte size +avroSize :: String +avroSize = "size" + +-- | The JSON type-name value identifying the Avro string primitive +avroString :: String +avroString = "string" + +-- | The JSON attribute name for an enum schema's list of symbols +avroSymbols :: String +avroSymbols = "symbols" + +-- | The JSON attribute name for a schema's type name +avroType :: String +avroType = "type" + +-- | The JSON attribute name for a map schema's value type +avroValues :: String +avroValues = "values" + +-- | Decode aliases from a JSON object map +decodeAliases :: t0 -> M.Map String JsonModel.Value -> Either t1 (Maybe [String]) +decodeAliases cx m = + Eithers.bind (optArrayE cx avroAliases m) (\mArr -> Optionals.match mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.given strs) (Eithers.mapList (expectStringE cx) arr))) + +-- | Decode an Avro array schema from a JSON object map +decodeArraySchema :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.Schema +decodeArraySchema cx m = + Eithers.bind (requireE cx avroItems m) (\items -> Eithers.map (\s -> Schema.SchemaArray (Schema.Array { + Schema.arrayItems = s})) (decodeSchema cx items)) + +-- | Decode an Avro enum type from a JSON object map +decodeEnum :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.NamedType +decodeEnum cx m = + Eithers.bind (requireArrayE cx avroSymbols m) (\syms -> Eithers.bind (Eithers.mapList (expectStringE cx) syms) (\symbols -> Eithers.bind (optStringE cx avroDefault m) (\defVal -> Right (Schema.NamedTypeEnum (Schema.Enum { + Schema.enumSymbols = symbols, + Schema.enumDefault = defVal}))))) + +-- | Decode an Avro field from a JSON object map +decodeField :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.Field +decodeField cx m = + Eithers.bind (requireStringE cx avroName m) (\name -> Eithers.bind (optStringE cx avroDoc m) (\fdoc -> Eithers.bind (requireE cx avroType m) (\typeJson -> Eithers.bind (decodeSchema cx typeJson) (\fieldType -> Eithers.bind (Eithers.bind (optStringE cx avroOrder m) (\mOrd -> Eithers.mapOptional (decodeOrder cx) mOrd)) (\order -> Eithers.bind (decodeAliases cx m) (\aliases -> Right (Schema.Field { + Schema.fieldName = name, + Schema.fieldDoc = fdoc, + Schema.fieldType = fieldType, + Schema.fieldDefault = (optE avroDefault m), + Schema.fieldOrder = order, + Schema.fieldAliases = aliases, + Schema.fieldAnnotations = (getAnnotations m)}))))))) + +-- | Decode an Avro fixed type from a JSON object map +decodeFixed :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.NamedType +decodeFixed cx m = + Eithers.bind (requireNumberE cx avroSize m) (\n -> + let size = Literals.bigintToInt32 (Literals.decimalToBigint n) + in (Right (Schema.NamedTypeFixed (Schema.Fixed { + Schema.fixedSize = size})))) + +-- | Decode an Avro map schema from a JSON object map +decodeMapSchema :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.Schema +decodeMapSchema cx m = + Eithers.bind (requireE cx avroValues m) (\values -> Eithers.map (\s -> Schema.SchemaMap (Schema.Map { + Schema.mapValues = s})) (decodeSchema cx values)) + +-- | Decode a named Avro schema from a JSON object map and a decoded named type result +decodeNamedSchema :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.NamedType -> Either Errors.Error Schema.Schema +decodeNamedSchema cx m namedTypeResult = + Eithers.bind (requireStringE cx avroName m) (\name -> Eithers.bind (optStringE cx avroNamespace m) (\ns -> Eithers.bind (optStringE cx avroDoc m) (\sdoc -> Eithers.bind (decodeAliases cx m) (\aliases -> Eithers.bind namedTypeResult (\namedType -> Right (Schema.SchemaNamed (Schema.Named { + Schema.namedName = name, + Schema.namedNamespace = ns, + Schema.namedAliases = aliases, + Schema.namedDoc = sdoc, + Schema.namedType = namedType, + Schema.namedAnnotations = (getAnnotations m)}))))))) + +-- | Decode an Avro schema from a JSON object given the type name +decodeObjectSchema :: t0 -> M.Map String JsonModel.Value -> String -> Either Errors.Error Schema.Schema +decodeObjectSchema cx m typeName = + Logic.ifElse (Equality.equal typeName "array") (decodeArraySchema cx m) (Logic.ifElse (Equality.equal typeName "map") (decodeMapSchema cx m) (Logic.ifElse (Equality.equal typeName "record") (decodeNamedSchema cx m (decodeRecord cx m)) (Logic.ifElse (Equality.equal typeName "enum") (decodeNamedSchema cx m (decodeEnum cx m)) (Logic.ifElse (Equality.equal typeName "fixed") (decodeNamedSchema cx m (decodeFixed cx m)) (Optionals.match (decodePrimitiveName typeName) (err cx (Strings.concat [ + "unknown type: ", + typeName])) (\p -> Right (Schema.SchemaPrimitive p))))))) + +-- | Decode an Avro field ordering from a string +decodeOrder :: t0 -> String -> Either Errors.Error Schema.Order +decodeOrder cx o = + Logic.ifElse (Equality.equal o "ascending") (Right Schema.OrderAscending) (Logic.ifElse (Equality.equal o "descending") (Right Schema.OrderDescending) (Logic.ifElse (Equality.equal o "ignore") (Right Schema.OrderIgnore) (err cx (Strings.concat [ + "unknown order: ", + o])))) + +-- | Decode a primitive type name string to a Primitive, or Nothing if not a primitive +decodePrimitiveName :: String -> Maybe Schema.Primitive +decodePrimitiveName s = + Logic.ifElse (Equality.equal s "null") (Just Schema.PrimitiveNull) (Logic.ifElse (Equality.equal s "boolean") (Just Schema.PrimitiveBoolean) (Logic.ifElse (Equality.equal s "int") (Just Schema.PrimitiveInt) (Logic.ifElse (Equality.equal s "long") (Just Schema.PrimitiveLong) (Logic.ifElse (Equality.equal s "float") (Just Schema.PrimitiveFloat) (Logic.ifElse (Equality.equal s "double") (Just Schema.PrimitiveDouble) (Logic.ifElse (Equality.equal s "bytes") (Just Schema.PrimitiveBytes) (Logic.ifElse (Equality.equal s "string") (Just Schema.PrimitiveString) Nothing))))))) + +-- | Decode an Avro record type from a JSON object map +decodeRecord :: t0 -> M.Map String JsonModel.Value -> Either Errors.Error Schema.NamedType +decodeRecord cx m = + Eithers.bind (requireArrayE cx avroFields m) (\fieldJsons -> Eithers.bind (Eithers.mapList (\fj -> Eithers.bind (expectObjectE cx fj) (\fm -> decodeField cx fm)) fieldJsons) (\fields -> Right (Schema.NamedTypeRecord (Schema.Record { + Schema.recordFields = fields})))) + +-- | Decode an Avro schema from a JSON value +decodeSchema :: t0 -> JsonModel.Value -> Either Errors.Error Schema.Schema +decodeSchema cx v = + case v of + JsonModel.ValueString v0 -> Optionals.match (decodePrimitiveName v0) (Right (Schema.SchemaReference v0)) (\p -> Right (Schema.SchemaPrimitive p)) + JsonModel.ValueArray v0 -> Eithers.map (\decoded -> Schema.SchemaUnion (Schema.Union decoded)) (Eithers.mapList (decodeSchema cx) v0) + JsonModel.ValueObject v0 -> + let m = Maps.fromList v0 + in (Eithers.bind (requireStringE cx avroType m) (\typeName -> decodeObjectSchema cx m typeName)) + _ -> err cx (Strings.concat [ + "unexpected JSON value for schema: ", + (showJsonValue v)]) + +-- | Encode annotations as key-value pairs with @ prefix on keys +encodeAnnotations :: M.Map String t0 -> [(String, t0)] +encodeAnnotations m = Lists.map (\entry -> (Strings.concat2 "@" (Pairs.first entry), (Pairs.second entry))) (Maps.toList m) + +-- | Encode an Avro array schema to a JSON object +encodeArray :: Schema.Array -> JsonModel.Value +encodeArray arr = + JsonModel.ValueObject [ + ("type", (JsonModel.ValueString "array")), + ("items", (encodeSchema (Schema.arrayItems arr)))] + +-- | Encode an Avro enum type as key-value pairs +encodeEnum :: Schema.Enum -> [(String, JsonModel.Value)] +encodeEnum e = + Lists.concat [ + [ + ("type", (JsonModel.ValueString "enum"))], + [ + ("symbols", (JsonModel.ValueArray (Lists.map (\s -> JsonModel.ValueString s) (Schema.enumSymbols e))))], + (Optionals.match (Schema.enumDefault e) [] (\d -> [ + ("default", (JsonModel.ValueString d))]))] + +-- | Encode an Avro field to a JSON object +encodeField :: Schema.Field -> JsonModel.Value +encodeField f = + JsonModel.ValueObject (Lists.concat [ + [ + ("name", (JsonModel.ValueString (Schema.fieldName f)))], + [ + ("type", (encodeSchema (Schema.fieldType f)))], + (Optionals.match (Schema.fieldDoc f) [] (\d -> [ + ("doc", (JsonModel.ValueString d))])), + (Optionals.match (Schema.fieldDefault f) [] (\d -> [ + ("default", d)])), + (Optionals.match (Schema.fieldOrder f) [] (\o -> [ + encodeOrder o])), + (Optionals.match (Schema.fieldAliases f) [] (\als -> [ + ("aliases", (JsonModel.ValueArray (Lists.map (\a -> JsonModel.ValueString a) als)))])), + (encodeAnnotations (Schema.fieldAnnotations f))]) + +-- | Encode an Avro fixed type as key-value pairs +encodeFixed :: Schema.Fixed -> [(String, JsonModel.Value)] +encodeFixed f = + [ + ("type", (JsonModel.ValueString "fixed")), + ("size", (JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint (Schema.fixedSize f)))))] + +-- | Encode an Avro map schema to a JSON object +encodeMap :: Schema.Map -> JsonModel.Value +encodeMap mp = + JsonModel.ValueObject [ + ("type", (JsonModel.ValueString "map")), + ("values", (encodeSchema (Schema.mapValues mp)))] + +-- | Encode an Avro named type to a JSON object +encodeNamed :: Schema.Named -> JsonModel.Value +encodeNamed n = + JsonModel.ValueObject (Lists.concat [ + [ + ("name", (JsonModel.ValueString (Schema.namedName n)))], + (Optionals.match (Schema.namedNamespace n) [] (\ns -> [ + ("namespace", (JsonModel.ValueString ns))])), + (Optionals.match (Schema.namedDoc n) [] (\d -> [ + ("doc", (JsonModel.ValueString d))])), + (Optionals.match (Schema.namedAliases n) [] (\als -> [ + ("aliases", (JsonModel.ValueArray (Lists.map (\a -> JsonModel.ValueString a) als)))])), + (encodeNamedType (Schema.namedType n)), + (encodeAnnotations (Schema.namedAnnotations n))]) + +-- | Encode the specific variant of a named Avro type +encodeNamedType :: Schema.NamedType -> [(String, JsonModel.Value)] +encodeNamedType nt = + case nt of + Schema.NamedTypeEnum v0 -> encodeEnum v0 + Schema.NamedTypeFixed v0 -> encodeFixed v0 + Schema.NamedTypeRecord v0 -> encodeRecord v0 + +-- | Encode an Avro field ordering as a key-value pair +encodeOrder :: Schema.Order -> (String, JsonModel.Value) +encodeOrder o = + ( + "order", + (JsonModel.ValueString (case o of + Schema.OrderAscending -> "ascending" + Schema.OrderDescending -> "descending" + Schema.OrderIgnore -> "ignore"))) + +-- | Encode an Avro primitive type as a JSON string +encodePrimitive :: Schema.Primitive -> JsonModel.Value +encodePrimitive p = + JsonModel.ValueString (case p of + Schema.PrimitiveNull -> "null" + Schema.PrimitiveBoolean -> "boolean" + Schema.PrimitiveInt -> "int" + Schema.PrimitiveLong -> "long" + Schema.PrimitiveFloat -> "float" + Schema.PrimitiveDouble -> "double" + Schema.PrimitiveBytes -> "bytes" + Schema.PrimitiveString -> "string") + +-- | Encode an Avro record type as key-value pairs +encodeRecord :: Schema.Record -> [(String, JsonModel.Value)] +encodeRecord r = + [ + ("type", (JsonModel.ValueString "record")), + ("fields", (JsonModel.ValueArray (Lists.map encodeField (Schema.recordFields r))))] + +-- | Encode an Avro schema to a JSON value +encodeSchema :: Schema.Schema -> JsonModel.Value +encodeSchema schema = + case schema of + Schema.SchemaPrimitive v0 -> encodePrimitive v0 + Schema.SchemaArray v0 -> encodeArray v0 + Schema.SchemaMap v0 -> encodeMap v0 + Schema.SchemaNamed v0 -> encodeNamed v0 + Schema.SchemaReference v0 -> JsonModel.ValueString v0 + Schema.SchemaUnion v0 -> encodeUnion v0 + +-- | Encode an Avro union as a JSON array of schemas +encodeUnion :: Schema.Union -> JsonModel.Value +encodeUnion u = JsonModel.ValueArray (Lists.map encodeSchema (Schema.unUnion u)) + +-- | Construct an error result with a message in context +err :: t0 -> String -> Either Errors.Error t1 +err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) + +-- | Extract a JSON array or return an error +expectArrayE :: t0 -> JsonModel.Value -> Either t1 [JsonModel.Value] +expectArrayE cx value = + case value of + JsonModel.ValueArray v0 -> Right v0 + +-- | Extract a JSON number or return an error +expectNumberE :: t0 -> JsonModel.Value -> Either t1 Sci.Scientific +expectNumberE cx value = + case value of + JsonModel.ValueNumber v0 -> Right v0 + +-- | Extract a JSON object as a name-keyed map or return an error (field order is dropped) +expectObjectE :: t0 -> JsonModel.Value -> Either t1 (M.Map String JsonModel.Value) +expectObjectE cx value = + case value of + JsonModel.ValueObject v0 -> Right (Maps.fromList v0) + +-- | Extract a JSON string or return an error +expectStringE :: t0 -> JsonModel.Value -> Either t1 String +expectStringE cx value = + case value of + JsonModel.ValueString v0 -> Right v0 + +-- | Extract annotation entries (keys starting with @) from a JSON object map +getAnnotations :: M.Map String t0 -> M.Map String t0 +getAnnotations m = + Maps.fromList (Optionals.givens (Lists.map (\entry -> + let k = Pairs.first entry + v = Pairs.second entry + in (Logic.ifElse (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 k)) 64) (Optionals.given (Strings.fromList (Lists.drop 1 (Strings.toList k)), v)) Nothing)) (Maps.toList m))) + +-- | Look up an optional array attribute in a JSON object map +optArrayE :: Ord t1 => (t0 -> t1 -> M.Map t1 JsonModel.Value -> Either t2 (Maybe [JsonModel.Value])) +optArrayE cx fname m = + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\a -> Optionals.given a) (expectArrayE cx v)) + +-- | Look up an optional attribute in a JSON object map +optE :: Ord t0 => (t0 -> M.Map t0 t1 -> Maybe t1) +optE k m = Maps.lookup k m + +-- | Look up an optional string attribute in a JSON object map +optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 JsonModel.Value -> Either t2 (Maybe String)) +optStringE cx fname m = + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) + +-- | Look up a required array attribute in a JSON object map +requireArrayE :: t0 -> String -> M.Map String JsonModel.Value -> Either Errors.Error [JsonModel.Value] +requireArrayE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectArrayE cx v) + +-- | Look up a required attribute in a JSON object map +requireE :: t0 -> String -> M.Map String t1 -> Either Errors.Error t1 +requireE cx fname m = + Optionals.match (Maps.lookup fname m) (err cx (Strings.concat [ + "required attribute ", + (Literals.printString fname), + " not found"])) (\v -> Right v) + +-- | Look up a required number attribute in a JSON object map +requireNumberE :: t0 -> String -> M.Map String JsonModel.Value -> Either Errors.Error Sci.Scientific +requireNumberE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectNumberE cx v) + +-- | Look up a required string attribute in a JSON object map +requireStringE :: t0 -> String -> M.Map String JsonModel.Value -> Either Errors.Error String +requireStringE cx fname m = Eithers.bind (requireE cx fname m) (\v -> expectStringE cx v) + +-- | Convert a JSON value to its string representation +showJsonValue :: JsonModel.Value -> String +showJsonValue v = Writer.printJson v + +-- | Parse a JSON string, returning Either for compatibility +stringToJsonValue :: String -> Either String JsonModel.Value +stringToJsonValue s = + (\x -> case x of + Parsing.ParseResultSuccess v0 -> Right (Parsing.parseSuccessValue v0) + Parsing.ParseResultFailure v0 -> Left (Parsing.parseErrorMessage v0)) (Parser.parseJson s) + +-- | Construct an error for unexpected values +unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 +unexpectedE cx expected found = + err cx (Strings.concat [ + "Expected ", + expected, + ", found: ", + found]) diff --git a/src/main/haskell/Hydra/Ext/Avro/Testing.hs b/src/main/haskell/Hydra/Ext/Avro/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Avro/Testing.hs @@ -0,0 +1,326 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Test case types for the bidirectional Avro coder + +module Hydra.Ext.Avro.Testing where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A test case for the bidirectional Avro coder +data AvroTestCase = + -- | Type-level forward mapping (Avro Schema -> Hydra Type) + AvroTestCaseTypeLevelForward TypeLevelForwardTestCase | + -- | Type-level reverse mapping (Hydra Type -> Avro Schema) + AvroTestCaseTypeLevelReverse TypeLevelReverseTestCase | + -- | Type-level round-trip starting from Avro (Avro -> Hydra -> Avro) + AvroTestCaseTypeLevelRoundTripAvro TypeLevelRoundTripAvroTestCase | + -- | Type-level round-trip starting from Hydra (Hydra -> Avro -> Hydra) + AvroTestCaseTypeLevelRoundTripHydra TypeLevelRoundTripHydraTestCase | + -- | Term-level forward mapping (JSON -> Hydra Term) + AvroTestCaseTermLevelForward TermLevelForwardTestCase | + -- | Term-level reverse mapping (Hydra Term -> JSON) + AvroTestCaseTermLevelReverse TermLevelReverseTestCase | + -- | Term-level round-trip starting from JSON (JSON -> Term -> JSON) + AvroTestCaseTermLevelRoundTripJson TermLevelRoundTripJsonTestCase | + -- | Term-level round-trip starting from a term (Term -> JSON -> Term) + AvroTestCaseTermLevelRoundTripTerm TermLevelRoundTripTermTestCase | + -- | Union-specific encoding and decoding + AvroTestCaseUnion UnionTestCase | + -- | Name mapping between Hydra and Avro + AvroTestCaseNameMapping NameMappingTestCase | + -- | Lossy conversion with annotation stashing + AvroTestCaseLossiness LossinessTestCase | + -- | Schema serialization to and from JSON + AvroTestCaseSchemaSerialization SchemaSerializationTestCase + deriving (Eq, Ord, Read, Show) + +_AvroTestCase = Model.Name "hydra.ext.avro.testing.AvroTestCase" + +_AvroTestCase_typeLevelForward = Model.Name "typeLevelForward" + +_AvroTestCase_typeLevelReverse = Model.Name "typeLevelReverse" + +_AvroTestCase_typeLevelRoundTripAvro = Model.Name "typeLevelRoundTripAvro" + +_AvroTestCase_typeLevelRoundTripHydra = Model.Name "typeLevelRoundTripHydra" + +_AvroTestCase_termLevelForward = Model.Name "termLevelForward" + +_AvroTestCase_termLevelReverse = Model.Name "termLevelReverse" + +_AvroTestCase_termLevelRoundTripJson = Model.Name "termLevelRoundTripJson" + +_AvroTestCase_termLevelRoundTripTerm = Model.Name "termLevelRoundTripTerm" + +_AvroTestCase_union = Model.Name "union" + +_AvroTestCase_nameMapping = Model.Name "nameMapping" + +_AvroTestCase_lossiness = Model.Name "lossiness" + +_AvroTestCase_schemaSerialization = Model.Name "schemaSerialization" + +-- | A test case which verifies that lossy conversions stash original information in annotations +data LossinessTestCase = + LossinessTestCase { + -- | A human-readable description of what this test case covers + lossinessTestCaseDescription :: String, + -- | The original Avro schema containing information that may be lost + lossinessTestCaseOriginalSchema :: Schema.Schema, + -- | The resulting Hydra type, which should carry annotations for any lost information + lossinessTestCaseHydraType :: Model.Type, + -- | The Avro schema recovered from the annotated Hydra type + lossinessTestCaseRecoveredSchema :: Schema.Schema, + -- | Whether the adapter reports this conversion as lossy + lossinessTestCaseIsLossy :: Bool} + deriving (Eq, Ord, Read, Show) + +_LossinessTestCase = Model.Name "hydra.ext.avro.testing.LossinessTestCase" + +_LossinessTestCase_description = Model.Name "description" + +_LossinessTestCase_originalSchema = Model.Name "originalSchema" + +_LossinessTestCase_hydraType = Model.Name "hydraType" + +_LossinessTestCase_recoveredSchema = Model.Name "recoveredSchema" + +_LossinessTestCase_isLossy = Model.Name "isLossy" + +-- | A test case for bidirectional name mapping between Hydra and Avro +data NameMappingTestCase = + NameMappingTestCase { + -- | A human-readable description of what this test case covers + nameMappingTestCaseDescription :: String, + -- | The Hydra name + nameMappingTestCaseHydraName :: Model.Name, + -- | The expected Avro qualified name (dotted string) + nameMappingTestCaseAvroName :: String, + -- | The expected Avro namespace, if any + nameMappingTestCaseAvroNamespace :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_NameMappingTestCase = Model.Name "hydra.ext.avro.testing.NameMappingTestCase" + +_NameMappingTestCase_description = Model.Name "description" + +_NameMappingTestCase_hydraName = Model.Name "hydraName" + +_NameMappingTestCase_avroName = Model.Name "avroName" + +_NameMappingTestCase_avroNamespace = Model.Name "avroNamespace" + +-- | A test case for Avro schema serialization to and from JSON +data SchemaSerializationTestCase = + SchemaSerializationTestCase { + -- | A human-readable description of what this test case covers + schemaSerializationTestCaseDescription :: String, + -- | The Avro schema + schemaSerializationTestCaseSchema :: Schema.Schema, + -- | The expected JSON representation of the schema + schemaSerializationTestCaseJson :: JsonModel.Value} + deriving (Eq, Ord, Read, Show) + +_SchemaSerializationTestCase = Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase" + +_SchemaSerializationTestCase_description = Model.Name "description" + +_SchemaSerializationTestCase_schema = Model.Name "schema" + +_SchemaSerializationTestCase_json = Model.Name "json" + +-- | A test case which encodes a JSON value as a Hydra term using an Avro schema +data TermLevelForwardTestCase = + TermLevelForwardTestCase { + -- | A human-readable description of what this test case covers + termLevelForwardTestCaseDescription :: String, + -- | The Avro schema describing the JSON value + termLevelForwardTestCaseSchema :: Schema.Schema, + -- | The input JSON value + termLevelForwardTestCaseJson :: JsonModel.Value, + -- | The expected Hydra term + termLevelForwardTestCaseTerm :: Model.Term} + deriving (Eq, Ord, Read, Show) + +_TermLevelForwardTestCase = Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase" + +_TermLevelForwardTestCase_description = Model.Name "description" + +_TermLevelForwardTestCase_schema = Model.Name "schema" + +_TermLevelForwardTestCase_json = Model.Name "json" + +_TermLevelForwardTestCase_term = Model.Name "term" + +-- | A test case which decodes a Hydra term to a JSON value using an Avro schema +data TermLevelReverseTestCase = + TermLevelReverseTestCase { + -- | A human-readable description of what this test case covers + termLevelReverseTestCaseDescription :: String, + -- | The Avro schema describing the expected JSON value + termLevelReverseTestCaseSchema :: Schema.Schema, + -- | The input Hydra term + termLevelReverseTestCaseTerm :: Model.Term, + -- | The expected JSON value + termLevelReverseTestCaseJson :: JsonModel.Value} + deriving (Eq, Ord, Read, Show) + +_TermLevelReverseTestCase = Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase" + +_TermLevelReverseTestCase_description = Model.Name "description" + +_TermLevelReverseTestCase_schema = Model.Name "schema" + +_TermLevelReverseTestCase_term = Model.Name "term" + +_TermLevelReverseTestCase_json = Model.Name "json" + +-- | A test case which encodes a JSON value as a Hydra term and decodes it back, verifying the result +data TermLevelRoundTripJsonTestCase = + TermLevelRoundTripJsonTestCase { + -- | A human-readable description of what this test case covers + termLevelRoundTripJsonTestCaseDescription :: String, + -- | The Avro schema describing the JSON value + termLevelRoundTripJsonTestCaseSchema :: Schema.Schema, + -- | The original JSON value + termLevelRoundTripJsonTestCaseJson :: JsonModel.Value, + -- | The expected JSON value after the round-trip, which may differ from the original due to normalization + termLevelRoundTripJsonTestCaseExpectedJson :: JsonModel.Value} + deriving (Eq, Ord, Read, Show) + +_TermLevelRoundTripJsonTestCase = Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase" + +_TermLevelRoundTripJsonTestCase_description = Model.Name "description" + +_TermLevelRoundTripJsonTestCase_schema = Model.Name "schema" + +_TermLevelRoundTripJsonTestCase_json = Model.Name "json" + +_TermLevelRoundTripJsonTestCase_expectedJson = Model.Name "expectedJson" + +-- | A test case which decodes a Hydra term to JSON and encodes it back, verifying the result +data TermLevelRoundTripTermTestCase = + TermLevelRoundTripTermTestCase { + -- | A human-readable description of what this test case covers + termLevelRoundTripTermTestCaseDescription :: String, + -- | The Hydra type of the term + termLevelRoundTripTermTestCaseType :: Model.Type, + -- | The original Hydra term + termLevelRoundTripTermTestCaseTerm :: Model.Term, + -- | The expected Hydra term after the round-trip, which may differ from the original due to normalization + termLevelRoundTripTermTestCaseExpectedTerm :: Model.Term} + deriving (Eq, Ord, Read, Show) + +_TermLevelRoundTripTermTestCase = Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase" + +_TermLevelRoundTripTermTestCase_description = Model.Name "description" + +_TermLevelRoundTripTermTestCase_type = Model.Name "type" + +_TermLevelRoundTripTermTestCase_term = Model.Name "term" + +_TermLevelRoundTripTermTestCase_expectedTerm = Model.Name "expectedTerm" + +-- | A test case which maps an Avro schema to a Hydra type and compares the result +data TypeLevelForwardTestCase = + TypeLevelForwardTestCase { + -- | A human-readable description of what this test case covers + typeLevelForwardTestCaseDescription :: String, + -- | The input Avro schema + typeLevelForwardTestCaseSchema :: Schema.Schema, + -- | The expected Hydra type + typeLevelForwardTestCaseType :: Model.Type} + deriving (Eq, Ord, Read, Show) + +_TypeLevelForwardTestCase = Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase" + +_TypeLevelForwardTestCase_description = Model.Name "description" + +_TypeLevelForwardTestCase_schema = Model.Name "schema" + +_TypeLevelForwardTestCase_type = Model.Name "type" + +-- | A test case which maps a Hydra type to an Avro schema and compares the result +data TypeLevelReverseTestCase = + TypeLevelReverseTestCase { + -- | A human-readable description of what this test case covers + typeLevelReverseTestCaseDescription :: String, + -- | The input Hydra type + typeLevelReverseTestCaseType :: Model.Type, + -- | The expected Avro schema + typeLevelReverseTestCaseSchema :: Schema.Schema} + deriving (Eq, Ord, Read, Show) + +_TypeLevelReverseTestCase = Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase" + +_TypeLevelReverseTestCase_description = Model.Name "description" + +_TypeLevelReverseTestCase_type = Model.Name "type" + +_TypeLevelReverseTestCase_schema = Model.Name "schema" + +-- | A test case which maps an Avro schema to a Hydra type and back, verifying the result +data TypeLevelRoundTripAvroTestCase = + TypeLevelRoundTripAvroTestCase { + -- | A human-readable description of what this test case covers + typeLevelRoundTripAvroTestCaseDescription :: String, + -- | The original Avro schema + typeLevelRoundTripAvroTestCaseSchema :: Schema.Schema, + -- | The expected Avro schema after the round-trip, which may differ from the original due to normalization or information loss + typeLevelRoundTripAvroTestCaseExpectedSchema :: Schema.Schema} + deriving (Eq, Ord, Read, Show) + +_TypeLevelRoundTripAvroTestCase = Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase" + +_TypeLevelRoundTripAvroTestCase_description = Model.Name "description" + +_TypeLevelRoundTripAvroTestCase_schema = Model.Name "schema" + +_TypeLevelRoundTripAvroTestCase_expectedSchema = Model.Name "expectedSchema" + +-- | A test case which maps a Hydra type to an Avro schema and back, verifying the result +data TypeLevelRoundTripHydraTestCase = + TypeLevelRoundTripHydraTestCase { + -- | A human-readable description of what this test case covers + typeLevelRoundTripHydraTestCaseDescription :: String, + -- | The original Hydra type + typeLevelRoundTripHydraTestCaseType :: Model.Type, + -- | The expected Hydra type after the round-trip, which may differ from the original due to normalization or information loss + typeLevelRoundTripHydraTestCaseExpectedType :: Model.Type} + deriving (Eq, Ord, Read, Show) + +_TypeLevelRoundTripHydraTestCase = Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase" + +_TypeLevelRoundTripHydraTestCase_description = Model.Name "description" + +_TypeLevelRoundTripHydraTestCase_type = Model.Name "type" + +_TypeLevelRoundTripHydraTestCase_expectedType = Model.Name "expectedType" + +-- | A test case for union type encoding and decoding, covering the various strategies for representing unions in Avro +data UnionTestCase = + UnionTestCase { + -- | A human-readable description of what this test case covers + unionTestCaseDescription :: String, + -- | The Hydra union type + unionTestCaseHydraType :: Model.Type, + -- | The expected Avro schema (enum for all-unit unions, record with optional fields for general unions) + unionTestCaseAvroSchema :: Schema.Schema, + -- | Pairs of corresponding Hydra terms and JSON values for this union + unionTestCaseTermPairs :: [(Model.Term, JsonModel.Value)]} + deriving (Eq, Ord, Read, Show) + +_UnionTestCase = Model.Name "hydra.ext.avro.testing.UnionTestCase" + +_UnionTestCase_description = Model.Name "description" + +_UnionTestCase_hydraType = Model.Name "hydraType" + +_UnionTestCase_avroSchema = Model.Name "avroSchema" + +_UnionTestCase_termPairs = Model.Name "termPairs" diff --git a/src/main/haskell/Hydra/Ext/Azure/Dtld.hs b/src/main/haskell/Hydra/Ext/Azure/Dtld.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Azure/Dtld.hs @@ -0,0 +1,747 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | An Azure Digital Twin Definition Language (DTLD) model. Based on: +-- | https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#digital-twins-definition-language +-- | DTLD features which are not currently included in this model: +-- | * geospatial schemas (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#geospatial-schemas) +-- | * semantic types and units (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#semantic-types) +-- | * model versioning (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#model-versioning) + +module Hydra.Ext.Azure.Dtld where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | A Command describes a function or operation that can be performed on any digital twin. +data Command = + Command { + -- | This must be 'Command' + commandType :: Iri, + -- | The 'programming' name of the command. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + commandName :: String, + -- | The ID of the command. If no @id is provided, the digital twin interface processor will assign one. + commandId :: (Maybe Dtmi), + -- | A comment for model authors + commandComment :: (Maybe String), + -- | A localizable description for display + commandDescription :: (Maybe String), + -- | A localizable name for display + commandDisplayName :: (Maybe String), + -- | This property is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time. + commandCommandType :: (Maybe CommandType), + -- | A description of the input to the Command + commandRequest :: (Maybe CommandPayload), + -- | A description of the output of the Command + commandResponse :: (Maybe CommandPayload)} + deriving (Eq, Ord, Read, Show) + +_Command = Model.Name "hydra.ext.azure.dtld.Command" + +_Command_type = Model.Name "type" + +_Command_name = Model.Name "name" + +_Command_id = Model.Name "id" + +_Command_comment = Model.Name "comment" + +_Command_description = Model.Name "description" + +_Command_displayName = Model.Name "displayName" + +_Command_commandType = Model.Name "commandType" + +_Command_request = Model.Name "request" + +_Command_response = Model.Name "response" + +-- | A CommandPayload describes the inputs to or the outputs from a Command. +data CommandPayload = + CommandPayload { + -- | The 'programming' name of the payload. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + commandPayloadName :: String, + -- | The data type of the payload + commandPayloadSchema :: Schema, + -- | The ID of the payload. If no @id is provided, the digital twin interface processor will assign one. + commandPayloadId :: (Maybe Dtmi), + -- | A comment for model authors + commandPayloadComment :: (Maybe String), + -- | A localizable description for display + commandPayloadDescription :: (Maybe String), + -- | A localizable name for display + commandPayloadDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_CommandPayload = Model.Name "hydra.ext.azure.dtld.CommandPayload" + +_CommandPayload_name = Model.Name "name" + +_CommandPayload_schema = Model.Name "schema" + +_CommandPayload_id = Model.Name "id" + +_CommandPayload_comment = Model.Name "comment" + +_CommandPayload_description = Model.Name "description" + +_CommandPayload_displayName = Model.Name "displayName" + +-- | CommandType is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time. +data CommandType = + CommandTypeSynchronous | + CommandTypeAsynchronous + deriving (Eq, Ord, Read, Show) + +_CommandType = Model.Name "hydra.ext.azure.dtld.CommandType" + +_CommandType_synchronous = Model.Name "synchronous" + +_CommandType_asynchronous = Model.Name "asynchronous" + +-- | Components enable interfaces to be composed of other interfaces. Components are different from relationships because they describe contents that are directly part of the interface. (A relationship describes a link between two interfaces.) +data Component = + Component { + -- | This must be 'Component' + componentType :: Iri, + -- | The 'programming' name of the component. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + componentName :: String, + -- | The data type of the component + componentSchema :: Interface, + -- | The ID of the component. If no @id is provided, the digital twin interface processor will assign one. + componentId :: (Maybe Dtmi), + -- | A comment for model authors + componentComment :: (Maybe String), + -- | A localizable description for display + componentDescription :: (Maybe String), + -- | A localizable name for display + componentDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_Component = Model.Name "hydra.ext.azure.dtld.Component" + +_Component_type = Model.Name "type" + +_Component_name = Model.Name "name" + +_Component_schema = Model.Name "schema" + +_Component_id = Model.Name "id" + +_Component_comment = Model.Name "comment" + +_Component_description = Model.Name "description" + +_Component_displayName = Model.Name "displayName" + +-- | A digital twin model identifier +newtype Dtmi = + Dtmi { + unDtmi :: String} + deriving (Eq, Ord, Read, Show) + +_Dtmi = Model.Name "hydra.ext.azure.dtld.Dtmi" + +-- | An EnumValue describes an element of an Enum. +data EnumValue = + EnumValue { + -- | The 'programming' name of the enum value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + enumValueName :: String, + -- | The on-the-wire value that maps to the EnumValue. EnumValue may be either an integer or a string and must be unique for all enum values in this enum. + enumValueEnumValue :: IntegerOrString, + -- | The ID of the enum value. If no @id is provided, the digital twin interface processor will assign one. + enumValueId :: (Maybe Dtmi), + -- | A comment for model authors + enumValueComment :: (Maybe String), + -- | A localizable description for display + enumValueDescription :: (Maybe String), + -- | A localizable name for display + enumValueDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_EnumValue = Model.Name "hydra.ext.azure.dtld.EnumValue" + +_EnumValue_name = Model.Name "name" + +_EnumValue_enumValue = Model.Name "enumValue" + +_EnumValue_id = Model.Name "id" + +_EnumValue_comment = Model.Name "comment" + +_EnumValue_description = Model.Name "description" + +_EnumValue_displayName = Model.Name "displayName" + +-- | A Field describes a field in an Object. +data Field = + Field { + -- | The 'programming' name of the field. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + fieldName :: String, + -- | The data type of the field + fieldSchema :: Schema, + -- | The ID of the field. If no @id is provided, the digital twin interface processor will assign one. + fieldId :: (Maybe Dtmi), + -- | A comment for model authors + fieldComment :: (Maybe String), + -- | A localizable description for display + fieldDescription :: (Maybe String), + -- | A localizable name for display + fieldDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_Field = Model.Name "hydra.ext.azure.dtld.Field" + +_Field_name = Model.Name "name" + +_Field_schema = Model.Name "schema" + +_Field_id = Model.Name "id" + +_Field_comment = Model.Name "comment" + +_Field_description = Model.Name "description" + +_Field_displayName = Model.Name "displayName" + +-- | A value which may be either an integer or a string +data IntegerOrString = + IntegerOrStringInteger Int | + IntegerOrStringString String + deriving (Eq, Ord, Read, Show) + +_IntegerOrString = Model.Name "hydra.ext.azure.dtld.IntegerOrString" + +_IntegerOrString_integer = Model.Name "integer" + +_IntegerOrString_string = Model.Name "string" + +-- | An Interface describes the contents (Telemetry, Properties, Commands, Relationships, and Components) of any digital twin. +data Interface = + Interface { + -- | A digital twin model identifier for the interface + interfaceId :: Dtmi, + -- | This must be 'Interface' + interfaceType :: Iri, + -- | The context to use when processing this interface. For this version, it must be set to 'dtmi:dtdl:context;2' + interfaceContext :: Iri, + -- | A comment for model authors + interfaceComment :: (Maybe String), + -- | A set of objects that define the contents (Telemetry, Properties, Commands, Relationships, and/or Components) of this interface + interfaceContents :: (Maybe (S.Set InterfaceContents)), + -- | A localizable description for display + interfaceDescription :: (Maybe String), + -- | A localizable name for display + interfaceDisplayName :: (Maybe String), + -- | A set of DTMIs that refer to interfaces this interface inherits from. Interfaces can inherit from multiple interfaces. + interfaceExtends :: (Maybe (S.Set Interface)), + -- | A set of IRIs or objects that refer to the reusable schemas within this interface. + interfaceSchemas :: (Maybe (S.Set SchemaInterface))} + deriving (Eq, Ord, Read, Show) + +_Interface = Model.Name "hydra.ext.azure.dtld.Interface" + +_Interface_id = Model.Name "id" + +_Interface_type = Model.Name "type" + +_Interface_context = Model.Name "context" + +_Interface_comment = Model.Name "comment" + +_Interface_contents = Model.Name "contents" + +_Interface_description = Model.Name "description" + +_Interface_displayName = Model.Name "displayName" + +_Interface_extends = Model.Name "extends" + +_Interface_schemas = Model.Name "schemas" + +-- | One of the kinds of content an Interface may contain: a Command, Component, Property, Relationship, or Telemetry +data InterfaceContents = + InterfaceContentsCommand Command | + InterfaceContentsComponent Component | + InterfaceContentsProperty Property | + InterfaceContentsRelationship Relationship | + InterfaceContentsTelemetry Telemetry + deriving (Eq, Ord, Read, Show) + +_InterfaceContents = Model.Name "hydra.ext.azure.dtld.InterfaceContents" + +_InterfaceContents_command = Model.Name "command" + +_InterfaceContents_component = Model.Name "component" + +_InterfaceContents_property = Model.Name "property" + +_InterfaceContents_relationship = Model.Name "relationship" + +_InterfaceContents_telemetry = Model.Name "telemetry" + +-- | An Internationalized Resource Identifier +newtype Iri = + Iri { + unIri :: String} + deriving (Eq, Ord, Read, Show) + +_Iri = Model.Name "hydra.ext.azure.dtld.Iri" + +-- | A MapKey describes the key in a Map. The schema of a MapKey must be string. +data MapKey = + MapKey { + -- | The 'programming' name of the map's key. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + mapKeyName :: String, + -- | The data type of the map's key + mapKeySchema :: Schema, + -- | The ID of the map key. If no @id is provided, the digital twin interface processor will assign one. + mapKeyId :: (Maybe Dtmi), + -- | A comment for model authors + mapKeyComment :: (Maybe String), + -- | A localizable description for display + mapKeyDescription :: (Maybe String), + -- | A localizable name for display + mapKeyDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_MapKey = Model.Name "hydra.ext.azure.dtld.MapKey" + +_MapKey_name = Model.Name "name" + +_MapKey_schema = Model.Name "schema" + +_MapKey_id = Model.Name "id" + +_MapKey_comment = Model.Name "comment" + +_MapKey_description = Model.Name "description" + +_MapKey_displayName = Model.Name "displayName" + +-- | A MapValue describes the values in a Map. +data MapValue = + MapValue { + -- | The 'programming' name of the map's value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + mapValueName :: String, + -- | The data type of the map's values + mapValueSchema :: Schema, + -- | The ID of the map value. If no @id is provided, the digital twin interface processor will assign one. + mapValueId :: (Maybe Dtmi), + -- | A comment for model authors + mapValueComment :: (Maybe String), + -- | A localizable description for display + mapValueDescription :: (Maybe String), + -- | A localizable name for display + mapValueDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_MapValue = Model.Name "hydra.ext.azure.dtld.MapValue" + +_MapValue_name = Model.Name "name" + +_MapValue_schema = Model.Name "schema" + +_MapValue_id = Model.Name "id" + +_MapValue_comment = Model.Name "comment" + +_MapValue_description = Model.Name "description" + +_MapValue_displayName = Model.Name "displayName" + +-- | A Property describes the read-only and read/write state of any digital twin. For example, a device serial number may be a read-only property, the desired temperature on a thermostat may be a read-write property; and the name of a room may be a read-write property. +data Property = + Property { + -- | This must at least be 'Property'. It can also include a semantic type. + propertyType :: Iri, + -- | The 'programming' name of the property. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.. + propertyName :: String, + -- | The data type of the Property + propertySchema :: Schema, + -- | The ID of the property. If no @id is provided, the digital twin interface processor will assign one. + propertyId :: (Maybe Dtmi), + -- | A comment for model authors + propertyComment :: (Maybe String), + -- | A localizable description for display + propertyDescription :: (Maybe String), + -- | A localizable name for display + propertyDisplayName :: (Maybe String), + -- | The unit type of the property. A semantic type is required for the unit property to be available. + propertyUnit :: (Maybe Unit), + -- | A boolean value that indicates whether the property is writable by an external source, such as an application, or not. The default value is false (read-only). + propertyWritable :: (Maybe Bool)} + deriving (Eq, Ord, Read, Show) + +_Property = Model.Name "hydra.ext.azure.dtld.Property" + +_Property_type = Model.Name "type" + +_Property_name = Model.Name "name" + +_Property_schema = Model.Name "schema" + +_Property_id = Model.Name "id" + +_Property_comment = Model.Name "comment" + +_Property_description = Model.Name "description" + +_Property_displayName = Model.Name "displayName" + +_Property_unit = Model.Name "unit" + +_Property_writable = Model.Name "writable" + +-- | A Relationship describes a link to another digital twin and enables graphs of digital twins to be created. Relationships are different from Components because they describe a link to a separate digital twin. +data Relationship = + Relationship { + -- | This must be 'Relationship' + relationshipType :: Iri, + -- | The 'programming' name of the relationship. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$. + relationshipName :: String, + -- | The ID of the relationship description. If no @id is provided, the digital twin interface processor will assign one. + relationshipId :: (Maybe Dtmi), + -- | A comment for model authors + relationshipComment :: (Maybe String), + -- | A localizable description for display + relationshipDescription :: (Maybe String), + -- | A localizable name for display + relationshipDisplayName :: (Maybe String), + -- | The maximum multiplicity for the target of the relationship. The default value is infinite (there may be an unlimited number of relationship instances for this relationship). + relationshipMaxMultiplicity :: (Maybe Int), + -- | The minimum multiplicity for the target of the relationship. The default value is 0 (this relationship is permitted to have no instances). In DTDL v2, minMultiplicity must always be 0. + relationshipMinMultiplicity :: (Maybe Int), + -- | A set of Properties that define relationship-specific state + relationshipProperties :: (Maybe (S.Set Property)), + -- | An interface ID. The default value (when target is not specified) is that the target may be any interface. + relationshipTarget :: (Maybe Interface), + -- | A boolean value that indicates whether the relationship is writable by an external source, such as an application, or not. The default value is false (read-only). + relationshipWritable :: (Maybe Bool)} + deriving (Eq, Ord, Read, Show) + +_Relationship = Model.Name "hydra.ext.azure.dtld.Relationship" + +_Relationship_type = Model.Name "type" + +_Relationship_name = Model.Name "name" + +_Relationship_id = Model.Name "id" + +_Relationship_comment = Model.Name "comment" + +_Relationship_description = Model.Name "description" + +_Relationship_displayName = Model.Name "displayName" + +_Relationship_maxMultiplicity = Model.Name "maxMultiplicity" + +_Relationship_minMultiplicity = Model.Name "minMultiplicity" + +_Relationship_properties = Model.Name "properties" + +_Relationship_target = Model.Name "target" + +_Relationship_writable = Model.Name "writable" + +-- | Schemas are used to describe the on-the-wire or serialized format of the data in a digital twin interface. A full set of primitive data types are provided, along with support for a variety of complex schemas in the forms of Arrays, Enums, Maps, and Objects. Schemas described through digital twin's schema definition language are compatible with popular serialization formats, including JSON, Avro, and Protobuf. +data Schema = + SchemaPrimitive_ SchemaPrimitive | + SchemaComplex_ SchemaComplex + deriving (Eq, Ord, Read, Show) + +_Schema = Model.Name "hydra.ext.azure.dtld.Schema" + +_Schema_primitive = Model.Name "primitive" + +_Schema_complex = Model.Name "complex" + +-- | An Array describes an indexable data type where each element is of the same schema. An Array elements' schema can itself be a primitive or complex schema. +data SchemaArray = + SchemaArray { + -- | This must be 'Array' + schemaArrayType :: Iri, + -- | The data type of the array elements + schemaArrayElementSchema :: Schema, + -- | The ID of the array. If no @id is provided, the digital twin interface processor will assign one. + schemaArrayId :: (Maybe Dtmi), + -- | A comment for model authors + schemaArrayComment :: (Maybe String), + -- | A localizable description for display + schemaArrayDescription :: (Maybe String), + -- | A localizable name for display + schemaArrayDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_SchemaArray = Model.Name "hydra.ext.azure.dtld.SchemaArray" + +_SchemaArray_type = Model.Name "type" + +_SchemaArray_elementSchema = Model.Name "elementSchema" + +_SchemaArray_id = Model.Name "id" + +_SchemaArray_comment = Model.Name "comment" + +_SchemaArray_description = Model.Name "description" + +_SchemaArray_displayName = Model.Name "displayName" + +-- | Complex schemas are designed for supporting complex data types made up of primitive data types. Currently the following complex schemas are provided: Array, Enum, Map, and Object. A complex schema can be specified directly as the value in a schema statement or described in the interface schemas set and referenced in the schema statement. +data SchemaComplex = + SchemaComplexArray SchemaArray | + SchemaComplexEnum SchemaEnum | + SchemaComplexMap SchemaMap | + SchemaComplexObject SchemaObject + deriving (Eq, Ord, Read, Show) + +_SchemaComplex = Model.Name "hydra.ext.azure.dtld.SchemaComplex" + +_SchemaComplex_array = Model.Name "array" + +_SchemaComplex_enum = Model.Name "enum" + +_SchemaComplex_map = Model.Name "map" + +_SchemaComplex_object = Model.Name "object" + +-- | An Enum describes a data type with a set of named labels that map to values. The values in an Enum can be either integers or strings, but the labels are always strings. +data SchemaEnum = + SchemaEnum { + -- | Enum + schemaEnumType :: Iri, + -- | A set of enum value and label mappings + schemaEnumEnumValues :: [EnumValue], + -- | The data type for the enum values. All enum values must be of the same type. + schemaEnumValueSchema :: IntegerOrString, + -- | The ID of the enum. If no @id is provided, the digital twin interface processor will assign one. + schemaEnumId :: (Maybe Dtmi), + -- | A comment for model authors + schemaEnumComment :: (Maybe String), + -- | A localizable description for display + schemaEnumDescription :: (Maybe String), + -- | A localizable name for display + schemaEnumDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_SchemaEnum = Model.Name "hydra.ext.azure.dtld.SchemaEnum" + +_SchemaEnum_type = Model.Name "type" + +_SchemaEnum_enumValues = Model.Name "enumValues" + +_SchemaEnum_valueSchema = Model.Name "valueSchema" + +_SchemaEnum_id = Model.Name "id" + +_SchemaEnum_comment = Model.Name "comment" + +_SchemaEnum_description = Model.Name "description" + +_SchemaEnum_displayName = Model.Name "displayName" + +-- | Within an interface definition, complex schemas may be defined for reusability across Telemetry, Properties, and Commands. This is designed to promote readability and improved maintenance because schemas that are reused can be defined once (per interface). Interface schemas are defined in the schemas property of an interface. +data SchemaInterface = + SchemaInterface { + -- | The globally unique identifier for the schema + schemaInterfaceId :: Dtmi, + -- | The type of complex schema. This must refer to one of the complex schema classes (Array, Enum, Map, or Object). + schemaInterfaceType :: SchemaInterfaceType, + -- | A comment for model authors + schemaInterfaceComment :: (Maybe String), + -- | A localizable description for display + schemaInterfaceDescription :: (Maybe String), + -- | A localizable name for display + schemaInterfaceDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_SchemaInterface = Model.Name "hydra.ext.azure.dtld.SchemaInterface" + +_SchemaInterface_id = Model.Name "id" + +_SchemaInterface_type = Model.Name "type" + +_SchemaInterface_comment = Model.Name "comment" + +_SchemaInterface_description = Model.Name "description" + +_SchemaInterface_displayName = Model.Name "displayName" + +-- | The type of a reusable interface schema: Array, Enum, Map, or Object +data SchemaInterfaceType = + SchemaInterfaceTypeArray SchemaArray | + SchemaInterfaceTypeEnum SchemaEnum | + SchemaInterfaceTypeMap SchemaMap | + SchemaInterfaceTypeObject SchemaObject + deriving (Eq, Ord, Read, Show) + +_SchemaInterfaceType = Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType" + +_SchemaInterfaceType_array = Model.Name "array" + +_SchemaInterfaceType_enum = Model.Name "enum" + +_SchemaInterfaceType_map = Model.Name "map" + +_SchemaInterfaceType_object = Model.Name "object" + +-- | A Map describes a data type of key-value pairs where the values share the same schema. The key in a Map must be a string. The values in a Map can be any schema. +data SchemaMap = + SchemaMap { + -- | Map + schemaMapType :: Iri, + -- | A description of the keys in the map + schemaMapMapKey :: MapKey, + -- | A description of the values in the map + schemaMapMapValue :: MapValue, + -- | The ID of the map. If no @id is provided, the digital twin interface processor will assign one. + schemaMapId :: (Maybe Dtmi), + -- | A comment for model authors + schemaMapComment :: (Maybe String), + -- | A localizable description for display + schemaMapDescription :: (Maybe String), + -- | A localizable name for display + schemaMapDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_SchemaMap = Model.Name "hydra.ext.azure.dtld.SchemaMap" + +_SchemaMap_type = Model.Name "type" + +_SchemaMap_mapKey = Model.Name "mapKey" + +_SchemaMap_mapValue = Model.Name "mapValue" + +_SchemaMap_id = Model.Name "id" + +_SchemaMap_comment = Model.Name "comment" + +_SchemaMap_description = Model.Name "description" + +_SchemaMap_displayName = Model.Name "displayName" + +-- | An Object describes a data type made up of named fields (like a struct in C). The fields in an Object map can be primitive or complex schemas. +data SchemaObject = + SchemaObject { + -- | Object + schemaObjectType :: Iri, + -- | A set of field descriptions, one for each field in the Object + schemaObjectFields :: (S.Set Field), + -- | The ID of the object. If no @id is provided, the digital twin interface processor will assign one. + schemaObjectId :: (Maybe Dtmi), + -- | A comment for model authors + schemaObjectComment :: (Maybe String), + -- | A localizable description for display + schemaObjectDescription :: (Maybe String), + -- | A localizable name for display + schemaObjectDisplayName :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_SchemaObject = Model.Name "hydra.ext.azure.dtld.SchemaObject" + +_SchemaObject_type = Model.Name "type" + +_SchemaObject_fields = Model.Name "fields" + +_SchemaObject_id = Model.Name "id" + +_SchemaObject_comment = Model.Name "comment" + +_SchemaObject_description = Model.Name "description" + +_SchemaObject_displayName = Model.Name "displayName" + +-- | A full set of primitive data types are provided and can be specified directly as the value in a schema statement in a digital twin interface. +data SchemaPrimitive = + -- | A boolean value + SchemaPrimitiveBoolean | + -- | A full-date as defined in section 5.6 of RFC 3339 + SchemaPrimitiveDate | + -- | A date-time as defined in RFC 3339 + SchemaPrimitiveDateTime | + -- | An IEEE 8-byte floating point + SchemaPrimitiveDouble | + -- | A duration in ISO 8601 format + SchemaPrimitiveDuration | + -- | An IEEE 4-byte floating point + SchemaPrimitiveFloat | + -- | A signed 4-byte integer + SchemaPrimitiveInteger | + -- | A signed 8-byte integer + SchemaPrimitiveLong | + -- | A UTF8 string + SchemaPrimitiveString | + -- | A full-time as defined in section 5.6 of RFC 3339 + SchemaPrimitiveTime + deriving (Eq, Ord, Read, Show) + +_SchemaPrimitive = Model.Name "hydra.ext.azure.dtld.SchemaPrimitive" + +_SchemaPrimitive_boolean = Model.Name "boolean" + +_SchemaPrimitive_date = Model.Name "date" + +_SchemaPrimitive_dateTime = Model.Name "dateTime" + +_SchemaPrimitive_double = Model.Name "double" + +_SchemaPrimitive_duration = Model.Name "duration" + +_SchemaPrimitive_float = Model.Name "float" + +_SchemaPrimitive_integer = Model.Name "integer" + +_SchemaPrimitive_long = Model.Name "long" + +_SchemaPrimitive_string = Model.Name "string" + +_SchemaPrimitive_time = Model.Name "time" + +-- | Telemetry describes the data emitted by any digital twin, whether the data is a regular stream of sensor readings or a computed stream of data, such as occupancy, or an occasional error or information message. +data Telemetry = + Telemetry { + -- | This must be at least 'Telemetry'. It can also include a semantic type + telemetryType :: Iri, + -- | The 'programming' name of the telemetry. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.. + telemetryName :: String, + -- | The data type of the Telemetry + telemetrySchema :: Schema, + -- | The ID of the telemetry. If no @id is provided, the digital twin interface processor will assign one. + telemetryId :: (Maybe Dtmi), + -- | A comment for model authors + telemetryComment :: (Maybe String), + -- | A localizable description for display + telemetryDescription :: (Maybe String), + -- | A localizable name for display + telemetryDisplayName :: (Maybe String), + -- | The unit type of the Telemetry. A semantic type is required for the unit property to be available. + telemetryUnit :: (Maybe Unit)} + deriving (Eq, Ord, Read, Show) + +_Telemetry = Model.Name "hydra.ext.azure.dtld.Telemetry" + +_Telemetry_type = Model.Name "type" + +_Telemetry_name = Model.Name "name" + +_Telemetry_schema = Model.Name "schema" + +_Telemetry_id = Model.Name "id" + +_Telemetry_comment = Model.Name "comment" + +_Telemetry_description = Model.Name "description" + +_Telemetry_displayName = Model.Name "displayName" + +_Telemetry_unit = Model.Name "unit" + +-- | The unit type of a Property or Telemetry value, available when a semantic type is present +newtype Unit = + Unit { + unUnit :: ()} + deriving (Eq, Ord, Read, Show) + +_Unit = Model.Name "hydra.ext.azure.dtld.Unit" diff --git a/src/main/haskell/Hydra/Ext/Cpp/Coder.hs b/src/main/haskell/Hydra/Ext/Cpp/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Coder.hs @@ -0,0 +1,748 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | C++ code generator: converts Hydra modules to C++ header files + +module Hydra.Ext.Cpp.Coder where + +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Decode.Model as DecodeModel +import qualified Hydra.Core.Dependencies as Dependencies +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Encode.Model as EncodeModel +import qualified Hydra.Core.Environment as Environment +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Predicates as Predicates +import qualified Hydra.Core.Print.Model as PrintModel +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Resolution as Resolution +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.Sorting as Sorting +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Cpp.Language as Language +import qualified Hydra.Ext.Cpp.Serde as Serde +import qualified Hydra.Ext.Cpp.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Convert a binding name to a file path +bindingNameToFilePath :: Model.Name -> String +bindingNameToFilePath name = + Names.nameToFilePath Util.CaseConventionLowerSnake Util.CaseConventionLowerSnake (File.FileExtension "h") name + +-- | Get the class name from a fully qualified Name +className :: Model.Name -> String +className name = sanitizeCppName (Names.localNameOf name) + +-- | Create a const reference parameter +constParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter +constParameter name typ = + Syntax.Parameter { + Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = typ, + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), + Syntax.parameterName = name, + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing} + +-- | Create a class declaration +cppClassDeclaration :: String -> [Syntax.BaseSpecifier] -> Maybe Syntax.ClassBody -> Syntax.Declaration +cppClassDeclaration name baseSpecs mbody = + Syntax.DeclarationClass (Syntax.ClassDeclaration { + Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { + Syntax.classSpecifierKey = Syntax.ClassKeyClass, + Syntax.classSpecifierName = name, + Syntax.classSpecifierInheritance = baseSpecs}, + Syntax.classDeclarationBody = mbody}) + +-- | Create an enum class declaration +cppEnumDeclaration :: String -> Maybe Syntax.ClassBody -> Syntax.Declaration +cppEnumDeclaration name mbody = + Syntax.DeclarationClass (Syntax.ClassDeclaration { + Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { + Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, + Syntax.classSpecifierName = name, + Syntax.classSpecifierInheritance = []}, + Syntax.classDeclarationBody = mbody}) + +-- | Create an enum forward declaration (no body) +cppEnumForwardDeclaration :: String -> Syntax.Declaration +cppEnumForwardDeclaration name = cppEnumDeclaration name Nothing + +-- | Convert a PostfixExpression to a full Expression +cppPostfixExpressionToCppExpression :: Syntax.PostfixExpression -> Syntax.Expression +cppPostfixExpressionToCppExpression pe = cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionPostfix pe) + +-- | Convert a PrimaryExpression to a full Expression +cppPrimaryExpressionToCppExpression :: Syntax.PrimaryExpression -> Syntax.Expression +cppPrimaryExpressionToCppExpression prim = cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary prim) + +-- | Convert a UnaryExpression to a full Expression +cppUnaryExpressionToCppExpression :: Syntax.UnaryExpression -> Syntax.Expression +cppUnaryExpressionToCppExpression ue = + Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression ue))) + +-- | Convert a UnaryExpression to a LogicalOrExpression +cppUnaryExpressionToCppLogicalOrExpression :: Syntax.UnaryExpression -> Syntax.LogicalOrExpression +cppUnaryExpressionToCppLogicalOrExpression ue = + Syntax.LogicalOrExpressionLogicalAnd (Syntax.LogicalAndExpressionInclusiveOr (Syntax.InclusiveOrExpressionExclusiveOr (Syntax.ExclusiveOrExpressionAnd (Syntax.AndExpressionEquality (Syntax.EqualityExpressionRelational (Syntax.RelationalExpressionShift (Syntax.ShiftExpressionAdditive (Syntax.AdditiveExpressionMultiplicative (Syntax.MultiplicativeExpressionUnary ue))))))))) + +-- | Create the accept() method implementation using a dynamic_cast chain +createAcceptImplementation :: Model.Name -> [Model.FieldType] -> Syntax.Declaration +createAcceptImplementation tname variants = + Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { + Syntax.templateDeclarationInline = False, + Syntax.templateDeclarationParameters = [ + "typename R"], + Syntax.templateDeclarationDeclaration = (Syntax.DeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), + Syntax.functionDeclarationName = (Strings.concat2 (className tname) "::accept"), + Syntax.functionDeclarationParameters = [ + Syntax.Parameter { + Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName tname) ""))), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), + Syntax.parameterName = "visitor", + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}], + Syntax.functionDeclarationSuffixSpecifiers = [ + Syntax.FunctionSpecifierSuffixConst], + Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement (Lists.map (\ft -> + let fname = Model.fieldTypeName ft + in (Syntax.StatementSelection (Syntax.SelectionStatement { + Syntax.selectionStatementCondition = (Syntax.ExpressionAssignment (Syntax.AssignmentExpressionAssignment (Syntax.ExplicitAssignment { + Syntax.explicitAssignmentLeft = (cppUnaryExpressionToCppLogicalOrExpression (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "auto ptr")))), + Syntax.explicitAssignmentOp = Syntax.AssignmentOperatorAssign, + Syntax.explicitAssignmentRight = (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier (Strings.concat2 (Strings.concat2 "dynamic_cast"))), + Syntax.functionCallOperationArguments = [ + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier "this")]}))))))}))), + Syntax.selectionStatementThenBranch = (Syntax.StatementCompound (Syntax.CompoundStatement [ + Syntax.StatementJump (Syntax.JumpStatementReturnValue (cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { + Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "visitor")), + Syntax.memberAccessOperationMember = "visit"})), + Syntax.functionCallOperationArguments = [ + cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionUnaryOp (Syntax.UnaryOperation { + Syntax.unaryOperationOperator = Syntax.UnaryOperatorDereference, + Syntax.unaryOperationOperand = (Syntax.UnaryExpressionPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "ptr")))}))]}))))])), + Syntax.selectionStatementElseBranch = (Just (createThrowStmt "std::runtime_error" createTypeIdNameCall))}))) variants)))}))}) + +-- | Create a constructor function body: default if no params, empty compound otherwise +createConstructorBody :: [t0] -> Syntax.FunctionBody +createConstructorBody params = + Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [])) + +-- | Create a function call expression +createFunctionCallExpr :: String -> [Syntax.Expression] -> Syntax.Expression +createFunctionCallExpr funcName args = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier funcName)), + Syntax.functionCallOperationArguments = args})) + +-- | Create a header file with pragma once, includes, and declarations +createHeaderFile :: [Syntax.IncludeDirective] -> [Syntax.Declaration] -> Syntax.Program +createHeaderFile includes decls = + Syntax.Program { + Syntax.programPreprocessorDirectives = [ + Syntax.PreprocessorDirectivePragma (Syntax.PragmaDirective { + Syntax.pragmaDirectiveContent = "once"})], + Syntax.programIncludes = includes, + Syntax.programDeclarations = decls} + +-- | Create an identifier expression +createIdentifierExpr :: String -> Syntax.Expression +createIdentifierExpr name = cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier name) + +-- | Create a less-than operator for a record type (trivial/placeholder implementation) +createLessThanOperator :: Model.Name -> t0 -> Syntax.Declaration +createLessThanOperator typeName fields = + Syntax.DeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [ + Syntax.FunctionSpecifierPrefixInline], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic Syntax.BasicTypeBool), + Syntax.functionDeclarationName = "operator<", + Syntax.functionDeclarationParameters = [ + unnamedParameter "lhs" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className typeName))), + (unnamedParameter "rhs" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className typeName))))], + Syntax.functionDeclarationSuffixSpecifiers = [], + Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [ + Syntax.StatementJump (Syntax.JumpStatementReturnValue (createLiteralBoolExpr False))]))}) + +-- | Create a boolean literal expression +createLiteralBoolExpr :: Bool -> Syntax.Expression +createLiteralBoolExpr val = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralBoolean (Syntax.BooleanLiteral val))) + +-- | Create an integer literal expression +createLiteralIntExpr :: Integer -> Syntax.Expression +createLiteralIntExpr val = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteralDecimal val))) + +-- | Create a partial visitor interface with default visit methods that delegate to otherwise() +createPartialVisitorInterface :: Model.Name -> [Model.FieldType] -> Syntax.Declaration +createPartialVisitorInterface tname variants = + Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { + Syntax.templateDeclarationInline = False, + Syntax.templateDeclarationParameters = [ + "typename R"], + Syntax.templateDeclarationDeclaration = (cppClassDeclaration (partialVisitorName tname) [ + Syntax.BaseSpecifier { + Syntax.baseSpecifierAccess = Syntax.AccessSpecifierPublic, + Syntax.baseSpecifierName = (Strings.concat2 (visitorName tname) "")}] (Just (Syntax.ClassBody (Lists.concat [ + [ + memberSpecificationPublic], + [ + Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [ + Syntax.FunctionSpecifierPrefixVirtual], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), + Syntax.functionDeclarationName = "otherwise", + Syntax.functionDeclarationParameters = [ + constParameter "value" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (className tname)))], + Syntax.functionDeclarationSuffixSpecifiers = [ + Syntax.FunctionSpecifierSuffixConst], + Syntax.functionDeclarationBody = Syntax.FunctionBodyPure}))], + (Lists.map (\ft -> + let fname = Model.fieldTypeName ft + in (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), + Syntax.functionDeclarationName = "visit", + Syntax.functionDeclarationParameters = [ + constParameter "value" (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (variantName tname fname)))], + Syntax.functionDeclarationSuffixSpecifiers = [ + Syntax.FunctionSpecifierSuffixOverride], + Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [ + Syntax.StatementJump (Syntax.JumpStatementReturnValue (createFunctionCallExpr "otherwise" [ + createIdentifierExpr "value"]))]))})))) variants)]))))}) + +-- | Create a template type (e.g. std::vector) +createTemplateType :: String -> [Syntax.TypeExpression] -> Syntax.TypeExpression +createTemplateType name args = + Syntax.TypeExpressionTemplate (Syntax.TemplateType { + Syntax.templateTypeName = name, + Syntax.templateTypeArguments = (Lists.map (\a -> Syntax.TemplateArgumentType a) args)}) + +-- | Create a throw statement +createThrowStmt :: String -> Syntax.Expression -> Syntax.Statement +createThrowStmt exceptionType arg = + Syntax.StatementJump (Syntax.JumpStatementThrow (createFunctionCallExpr exceptionType [ + arg])) + +-- | Create a typeid(*this).name() call expression +createTypeIdNameCall :: Syntax.Expression +createTypeIdNameCall = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { + Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "typeid")), + Syntax.functionCallOperationArguments = [ + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized (cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "*this"))))]})), + Syntax.memberAccessOperationMember = "name"})), + Syntax.functionCallOperationArguments = []})) + +-- | Create a type reference, optionally as a shared_ptr for struct types +createTypeReference :: Bool -> Model.Name -> Syntax.TypeExpression +createTypeReference isPointer name = + Logic.ifElse isPointer (createTemplateType "std::shared_ptr" [ + toConstType (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Names.localNameOf name))))]) (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Names.localNameOf name)))) + +-- | Create the union base class with protected constructor, virtual destructor, and accept method +createUnionBaseClass :: Model.Name -> t0 -> Syntax.Declaration +createUnionBaseClass name variants = + cppClassDeclaration (className name) [] (Just (Syntax.ClassBody [ + memberSpecificationProtected, + (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { + Syntax.constructorDeclarationName = (className name), + Syntax.constructorDeclarationParameters = [], + Syntax.constructorDeclarationInitializers = [], + Syntax.constructorDeclarationBody = Syntax.FunctionBodyDefault}))), + memberSpecificationPublic, + (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationDestructor (Syntax.DestructorDeclaration { + Syntax.destructorDeclarationPrefixSpecifiers = [ + Syntax.FunctionSpecifierPrefixVirtual], + Syntax.destructorDeclarationName = (className name), + Syntax.destructorDeclarationSuffixSpecifiers = [], + Syntax.destructorDeclarationBody = Syntax.FunctionBodyDefault}))), + (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationTemplate (Syntax.TemplateDeclaration { + Syntax.templateDeclarationInline = False, + Syntax.templateDeclarationParameters = [ + "typename R"], + Syntax.templateDeclarationDeclaration = (Syntax.DeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), + Syntax.functionDeclarationName = "accept", + Syntax.functionDeclarationParameters = [ + Syntax.Parameter { + Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName name) ""))), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), + Syntax.parameterName = "visitor", + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}], + Syntax.functionDeclarationSuffixSpecifiers = [ + Syntax.FunctionSpecifierSuffixConst], + Syntax.functionDeclarationBody = Syntax.FunctionBodyDeclaration}))})))])) + +-- | Create a variant subclass (one branch of a union type) +createVariantClass :: t0 -> t1 -> Model.Name -> Model.Name -> Model.FieldType -> Either Errors.Error Syntax.Declaration +createVariantClass cx g tname parentClass ft = + + let fname = Model.fieldTypeName ft + variantType = Model.fieldTypeType ft + hasValue = Logic.not (Predicates.isUnitType variantType) + valueField = + Logic.ifElse hasValue (Eithers.map (\cppType -> [ + Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable (Syntax.VariableDeclaration { + Syntax.variableDeclarationType = (Just cppType), + Syntax.variableDeclarationName = "value", + Syntax.variableDeclarationInitializer = Nothing, + Syntax.variableDeclarationIsAuto = False}))]) (encodeType cx g (Strip.deannotateType variantType))) (Right []) + constructorParams = + Logic.ifElse hasValue (Eithers.map (\paramType -> [ + Syntax.Parameter { + Syntax.parameterType = paramType, + Syntax.parameterName = "value", + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}]) (encodeType cx g (Strip.deannotateType variantType))) (Right []) + in (Eithers.bind valueField (\vFields -> Eithers.bind constructorParams (\vParams -> + let initList = + Logic.ifElse hasValue [ + Syntax.MemInitializer { + Syntax.memInitializerName = "value", + Syntax.memInitializerArguments = [ + createIdentifierExpr "value"]}] [] + in (Right (cppClassDeclaration (variantName tname fname) [ + Syntax.BaseSpecifier { + Syntax.baseSpecifierAccess = Syntax.AccessSpecifierPublic, + Syntax.baseSpecifierName = (className parentClass)}] (Just (Syntax.ClassBody (Lists.concat [ + [ + memberSpecificationPublic], + vFields, + [ + Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { + Syntax.constructorDeclarationName = (variantName tname fname), + Syntax.constructorDeclarationParameters = vParams, + Syntax.constructorDeclarationInitializers = initList, + Syntax.constructorDeclarationBody = (createConstructorBody vParams)}))]])))))))) + +-- | Create a visitor interface with pure virtual visit methods +createVisitorInterface :: Model.Name -> [Model.FieldType] -> Syntax.Declaration +createVisitorInterface tname variants = + Syntax.DeclarationTemplate (Syntax.TemplateDeclaration { + Syntax.templateDeclarationInline = False, + Syntax.templateDeclarationParameters = [ + "typename R"], + Syntax.templateDeclarationDeclaration = (cppClassDeclaration (visitorName tname) [] (Just (Syntax.ClassBody (Lists.concat [ + [ + memberSpecificationPublic], + (Lists.map (\ft -> + let fname = Model.fieldTypeName ft + in (Syntax.MemberSpecificationMember (Syntax.MemberDeclarationFunction (Syntax.FunctionDeclaration { + Syntax.functionDeclarationPrefixSpecifiers = [ + Syntax.FunctionSpecifierPrefixVirtual], + Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")), + Syntax.functionDeclarationName = "visit", + Syntax.functionDeclarationParameters = [ + Syntax.Parameter { + Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (variantName tname fname))), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), + Syntax.parameterName = "value", + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}], + Syntax.functionDeclarationSuffixSpecifiers = [], + Syntax.functionDeclarationBody = Syntax.FunctionBodyPure})))) variants), + [ + Syntax.MemberSpecificationMember (Syntax.MemberDeclarationDestructor (Syntax.DestructorDeclaration { + Syntax.destructorDeclarationPrefixSpecifiers = [ + Syntax.FunctionSpecifierPrefixVirtual], + Syntax.destructorDeclarationName = (visitorName tname), + Syntax.destructorDeclarationSuffixSpecifiers = [], + Syntax.destructorDeclarationBody = Syntax.FunctionBodyDefault}))]]))))}) + +-- | Encode a type application (template instantiation) +encodeApplicationType :: t0 -> t1 -> Model.ApplicationType -> Either Errors.Error Syntax.TypeExpression +encodeApplicationType cx g at = + Eithers.bind (encodeType cx g (Model.applicationTypeFunction at)) (\body -> Eithers.bind (encodeType cx g (Model.applicationTypeArgument at)) (\arg -> Right (createTemplateType "TODO_template" [ + body, + arg]))) + +-- | Encode an enum type as a C++ enum class +encodeEnumType :: t0 -> t1 -> Model.Name -> [Model.FieldType] -> t2 -> Either t3 [Syntax.Declaration] +encodeEnumType cx g name tfields comment = + Right [ + cppEnumDeclaration (className name) (Just (Syntax.ClassBody (Lists.map (\ft -> Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable (Syntax.VariableDeclaration { + Syntax.variableDeclarationType = Nothing, + Syntax.variableDeclarationName = (encodeEnumValue (Model.fieldTypeName ft)), + Syntax.variableDeclarationInitializer = Nothing, + Syntax.variableDeclarationIsAuto = False}))) tfields)))] + +-- | Encode an enum value in UPPER_SNAKE_CASE +encodeEnumValue :: Model.Name -> String +encodeEnumValue fname = sanitizeCppName (Formatting.convertCaseCamelToUpperSnake (Model.unName fname)) + +-- | Encode a field name in lower_snake_case +encodeFieldName :: Model.Name -> String +encodeFieldName fname = sanitizeCppName (Formatting.convertCaseCamelToLowerSnake (Model.unName fname)) + +-- | Encode a field type as a VariableDeclaration +encodeFieldType :: t0 -> Model.FieldType -> t1 -> t2 -> Either Errors.Error Syntax.VariableDeclaration +encodeFieldType isParameter ft cx g = + + let fname = Model.fieldTypeName ft + ftype = Model.fieldTypeType ft + in (Eithers.bind (encodeType cx g ftype) (\cppType -> Right (Syntax.VariableDeclaration { + Syntax.variableDeclarationType = (Just cppType), + Syntax.variableDeclarationName = (encodeFieldName fname), + Syntax.variableDeclarationInitializer = Nothing, + Syntax.variableDeclarationIsAuto = False}))) + +-- | Encode a forall type (strip the quantifier) +encodeForallType :: t0 -> t1 -> Model.ForallType -> Either Errors.Error Syntax.TypeExpression +encodeForallType cx g lt = encodeType cx g (Model.forallTypeBody lt) + +-- | Encode a function type as std::function +encodeFunctionType :: t0 -> t1 -> Model.FunctionType -> Either Errors.Error Syntax.TypeExpression +encodeFunctionType cx g ft = + Eithers.bind (encodeType cx g (Model.functionTypeDomain ft)) (\dom -> Eithers.bind (encodeType cx g (Model.functionTypeCodomain ft)) (\cod -> Right (Syntax.TypeExpressionFunction (Syntax.FunctionType { + Syntax.functionTypeReturnType = cod, + Syntax.functionTypeParameters = [ + Syntax.Parameter { + Syntax.parameterType = dom, + Syntax.parameterName = "", + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}]})))) + +-- | Encode a literal type as a C++ type expression +encodeLiteralType :: Model.LiteralType -> Syntax.TypeExpression +encodeLiteralType lt = + Syntax.TypeExpressionBasic (case lt of + Model.LiteralTypeBinary -> Syntax.BasicTypeChar + Model.LiteralTypeBoolean -> Syntax.BasicTypeBool + Model.LiteralTypeFloat v0 -> case v0 of + Model.FloatTypeFloat32 -> Syntax.BasicTypeFloat + Model.FloatTypeFloat64 -> Syntax.BasicTypeDouble + _ -> Syntax.BasicTypeDouble + Model.LiteralTypeInteger v0 -> case v0 of + Model.IntegerTypeBigint -> Syntax.BasicTypeInt + Model.IntegerTypeInt8 -> Syntax.BasicTypeChar + Model.IntegerTypeInt16 -> Syntax.BasicTypeNamed "int16_t" + Model.IntegerTypeInt32 -> Syntax.BasicTypeInt + Model.IntegerTypeInt64 -> Syntax.BasicTypeNamed "int64_t" + _ -> Syntax.BasicTypeInt + Model.LiteralTypeString -> Syntax.BasicTypeString) + +-- | Encode a name with a specified case convention, optionally qualified +encodeName :: t0 -> t1 -> t2 -> Model.Name -> String +encodeName isQualified conv env name = sanitizeCppName (Names.localNameOf name) + +-- | Encode a namespace as a C++ namespace string (e.g. "hydra.cpp" -> "hydra::cpp") +encodeNamespace :: Packaging.ModuleName -> String +encodeNamespace ns = + Strings.join "::" (Lists.map (\seg -> Formatting.convertCaseCamelToLowerSnake seg) (Strings.splitOn "." (Packaging.unModuleName ns))) + +-- | Encode a record type as a C++ class with fields and constructor +encodeRecordType :: t0 -> t1 -> Model.Name -> [Model.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] +encodeRecordType cx g name rt comment = + Eithers.bind (Eithers.mapList (\f -> encodeFieldType False f cx g) rt) (\cppFields -> Eithers.bind (Eithers.mapList (\f -> encodeFieldType True f cx g) rt) (\constructorParams -> Right [ + cppClassDeclaration (className name) [] (Just (Syntax.ClassBody (Lists.concat [ + [ + memberSpecificationPublic], + (Lists.map (\field -> Syntax.MemberSpecificationMember (Syntax.MemberDeclarationVariable field)) cppFields), + [ + Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration { + Syntax.constructorDeclarationName = (className name), + Syntax.constructorDeclarationParameters = (Lists.map (\p -> Syntax.Parameter { + Syntax.parameterType = (Optionals.withDefault (Syntax.TypeExpressionBasic Syntax.BasicTypeInt) (Syntax.variableDeclarationType p)), + Syntax.parameterName = (Syntax.variableDeclarationName p), + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing}) constructorParams), + Syntax.constructorDeclarationInitializers = (Lists.map (\field -> Syntax.MemInitializer { + Syntax.memInitializerName = (Syntax.variableDeclarationName field), + Syntax.memInitializerArguments = [ + createIdentifierExpr (Syntax.variableDeclarationName field)]}) cppFields), + Syntax.constructorDeclarationBody = (createConstructorBody constructorParams)}))]]))), + (createLessThanOperator name rt)])) + +-- | Encode a Hydra type as a C++ type expression +encodeType :: t0 -> t1 -> Model.Type -> Either Errors.Error Syntax.TypeExpression +encodeType cx g typ = + + let t = Strip.deannotateType typ + in case t of + Model.TypeApplication v0 -> encodeApplicationType cx g v0 + Model.TypeEither v0 -> Eithers.bind (encodeType cx g (Model.eitherTypeLeft v0)) (\lt -> Eithers.bind (encodeType cx g (Model.eitherTypeRight v0)) (\rt -> Right (toConstType (createTemplateType "std::variant" [ + lt, + rt])))) + Model.TypeFunction v0 -> encodeFunctionType cx g v0 + Model.TypeForall v0 -> encodeForallType cx g v0 + Model.TypeList v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::vector" [ + enc])) (encodeType cx g v0) + Model.TypeMap v0 -> Eithers.bind (encodeType cx g (Model.mapTypeKeys v0)) (\kt -> Eithers.bind (encodeType cx g (Model.mapTypeValues v0)) (\vt -> Right (toConstType (createTemplateType "std::map" [ + kt, + vt])))) + Model.TypeLiteral v0 -> Right (encodeLiteralType v0) + Model.TypeOptional v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::optional" [ + enc])) (encodeType cx g v0) + Model.TypePair v0 -> Eithers.bind (encodeType cx g (Model.pairTypeFirst v0)) (\ft -> Eithers.bind (encodeType cx g (Model.pairTypeSecond v0)) (\st -> Right (toConstType (createTemplateType "std::pair" [ + ft, + st])))) + Model.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) + Model.TypeSet v0 -> Eithers.map (\enc -> toConstType (createTemplateType "std::set" [ + enc])) (encodeType cx g v0) + Model.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) + Model.TypeVariable v0 -> Right (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (sanitizeCppName (Model.unName v0)))) + Model.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrapped type")) + Model.TypeUnit -> Right (createTemplateType "std::tuple" []) + _ -> Left (Errors.ErrorOther (Errors.OtherError "Unsupported type")) + +-- | Encode a type as a typedef / using declaration +encodeTypeAlias :: t0 -> t1 -> Model.Name -> Model.Type -> t2 -> Either Errors.Error Syntax.Declaration +encodeTypeAlias cx g name typ comment = + Eithers.bind (encodeType cx g typ) (\cppType -> Right (Syntax.DeclarationTypedef (Syntax.TypedefDeclaration { + Syntax.typedefDeclarationName = (className name), + Syntax.typedefDeclarationType = cppType, + Syntax.typedefDeclarationIsUsing = True}))) + +-- | Encode a top-level type definition (dispatches to record/union/wrap) +encodeTypeDefinition :: t0 -> t1 -> Model.Name -> Model.Type -> Either Errors.Error [Syntax.Declaration] +encodeTypeDefinition cx g name typ = + + let t = Strip.deannotateType typ + in case t of + Model.TypeForall v0 -> encodeTypeDefinition cx g name (Model.forallTypeBody v0) + Model.TypeRecord v0 -> encodeRecordType cx g name v0 Nothing + Model.TypeUnion v0 -> encodeUnionType cx g name v0 Nothing + Model.TypeWrap v0 -> encodeWrappedType cx g name v0 Nothing + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "unexpected type in definition: " (PrintModel.type_ typ)))) + +-- | Encode a union type (dispatches to enum or variant based on content) +encodeUnionType :: t0 -> t1 -> Model.Name -> [Model.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] +encodeUnionType cx g name rt comment = + Logic.ifElse (Predicates.isEnumRowType rt) (encodeEnumType cx g name rt comment) (encodeVariantType cx g name rt comment) + +-- | Encode a variant (tagged union) type as a class hierarchy with visitor pattern +encodeVariantType :: t0 -> t1 -> Model.Name -> [Model.FieldType] -> t2 -> Either Errors.Error [Syntax.Declaration] +encodeVariantType cx g name variants comment = + Eithers.bind (Eithers.mapList (\v -> createVariantClass cx g name name v) variants) (\variantClasses -> Right (Lists.concat [ + generateForwardDeclarations name variants, + [ + createVisitorInterface name variants], + [ + createUnionBaseClass name variants], + variantClasses, + [ + createPartialVisitorInterface name variants], + [ + createAcceptImplementation name variants]])) + +-- | Encode a wrapped type as a single-field record +encodeWrappedType :: t0 -> t1 -> Model.Name -> Model.Type -> t2 -> Either Errors.Error [Syntax.Declaration] +encodeWrappedType cx g name typ comment = + encodeRecordType cx g name [ + Model.FieldType { + Model.fieldTypeName = (Model.Name "value"), + Model.fieldTypeType = typ}] comment + +-- | Find includes for a set of type definitions +findIncludes :: Bool -> Packaging.ModuleName -> [Packaging.TypeDefinition] -> [Syntax.IncludeDirective] +findIncludes withFwd ns defs = + Lists.concat [ + [ + Syntax.IncludeDirective { + Syntax.includeDirectiveName = "memory", + Syntax.includeDirectiveIsSystem = True}, + Syntax.IncludeDirective { + Syntax.includeDirectiveName = "stdexcept", + Syntax.includeDirectiveIsSystem = True}], + (Lists.map (\depName -> Syntax.IncludeDirective { + Syntax.includeDirectiveName = (bindingNameToFilePath depName), + Syntax.includeDirectiveIsSystem = False}) (findTypeDependencies ns defs)), + (Logic.ifElse withFwd [ + Syntax.IncludeDirective { + Syntax.includeDirectiveName = (bindingNameToFilePath (fwdHeaderName ns)), + Syntax.includeDirectiveIsSystem = False}] [])] + +-- | Find type dependencies that are in other namespaces +findTypeDependencies :: Packaging.ModuleName -> [Packaging.TypeDefinition] -> [Model.Name] +findTypeDependencies ns defs = + Lists.filter (\n -> Logic.not (Equality.equal (Optionals.map Packaging.unModuleName (Names.moduleNameOf n)) (Just (Packaging.unModuleName ns)))) (Sets.toList (Lists.foldl (\acc -> \d -> Sets.union acc (Dependencies.typeDependencyNames True (Model.typeSchemeBody (Packaging.typeDefinitionBody d)))) Sets.empty defs)) + +-- | Construct the forward-declaration header name for a namespace +fwdHeaderName :: Packaging.ModuleName -> Model.Name +fwdHeaderName ns = + Names.unqualifyName (Util.QualifiedName { + Util.qualifiedNameModuleName = (Just ns), + Util.qualifiedNameLocal = "Fwd"}) + +-- | Gather metadata from definitions (simplified: always include common headers) +gatherMetadata :: t0 -> Bool +gatherMetadata defs = True + +-- | Generate forward declarations for all variant subclasses +generateForwardDeclarations :: Model.Name -> [Model.FieldType] -> [Syntax.Declaration] +generateForwardDeclarations tname fields = + Lists.map (\ft -> cppClassDeclaration (variantName tname (Model.fieldTypeName ft)) [] Nothing) fields + +-- | Generate a single type header file +generateTypeFile :: Packaging.ModuleName -> Packaging.TypeDefinition -> t0 -> t1 -> Either Errors.Error (String, String) +generateTypeFile ns def_ cx g = + + let name = Packaging.typeDefinitionName def_ + typ = Model.typeSchemeBody (Packaging.typeDefinitionBody def_) + in (Eithers.bind (encodeTypeDefinition cx g name typ) (\decls -> + let includes = findIncludes True ns [ + def_] + in (Right (serializeHeaderFile name includes [ + namespaceDecl ns decls])))) + +-- | Generate all type header files for a module (fwd file + individual class files) +generateTypeFiles :: Packaging.ModuleName -> [Packaging.TypeDefinition] -> t0 -> t1 -> Either Errors.Error [(String, String)] +generateTypeFiles ns defs cx g = + Eithers.bind (Eithers.mapList (\d -> generateTypeFile ns d cx g) defs) (\classFiles -> Right classFiles) + +-- | Check whether a type maps to an STL container type +isStdContainerType :: Model.Type -> Bool +isStdContainerType typ = + + let t = Strip.deannotateType typ + in case t of + Model.TypeApplication v0 -> isStdContainerType (Model.applicationTypeFunction v0) + Model.TypeList _ -> True + Model.TypeMap _ -> True + Model.TypeOptional _ -> True + Model.TypeSet _ -> True + _ -> False + +-- | Check whether a type is a struct type (not a literal and not an enum) +isStructType :: Model.Type -> Bool +isStructType rawType = + + let t = Resolution.fullyStripType rawType + isLiteral = + case t of + Model.TypeLiteral _ -> True + _ -> False + in (Logic.and (Logic.not isLiteral) (Logic.not (Predicates.isEnumType rawType))) + +-- | Check whether a type maps to a C++ template type (string or STL container) +isTemplateType :: Model.Type -> Bool +isTemplateType typ = + + let t = Strip.deannotateType typ + in (Logic.or (case t of + Model.TypeLiteral v0 -> case v0 of + Model.LiteralTypeString -> True + _ -> False + _ -> False) (isStdContainerType typ)) + +-- | A protected access label +memberSpecificationProtected :: Syntax.MemberSpecification +memberSpecificationProtected = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierProtected + +-- | A public access label +memberSpecificationPublic :: Syntax.MemberSpecification +memberSpecificationPublic = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierPublic + +-- | Convert a module to C++ code files (entry point) +moduleToCpp :: Packaging.Module -> [Packaging.Definition] -> t0 -> t1 -> Either Errors.Error (M.Map String String) +moduleToCpp mod defs cx g = + + let ns = Packaging.moduleName mod + typeDefs = Pairs.first (Environment.partitionDefinitions defs) + in (Eithers.bind (generateTypeFiles ns typeDefs cx g) (\typeFiles -> Right (Maps.fromList typeFiles))) + +-- | Create a namespace declaration wrapping declarations +namespaceDecl :: Packaging.ModuleName -> [Syntax.Declaration] -> Syntax.Declaration +namespaceDecl ns decls = + Syntax.DeclarationNamespace (Syntax.NamespaceDeclaration { + Syntax.namespaceDeclarationName = (encodeNamespace ns), + Syntax.namespaceDeclarationDeclarations = decls}) + +-- | Construct a partial visitor interface name +partialVisitorName :: Model.Name -> String +partialVisitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "PartialVisitor") + +-- | Sanitize a name to be valid in C++ +sanitizeCppName :: String -> String +sanitizeCppName name = Formatting.sanitizeWithUnderscores Language.cppReservedWords name + +-- | Serialize a header file from name, includes, and declarations +serializeHeaderFile :: Model.Name -> [Syntax.IncludeDirective] -> [Syntax.Declaration] -> (String, String) +serializeHeaderFile name includes decls = + ( + bindingNameToFilePath name, + (Serialization.printExpr (Serialization.parenthesize (Serde.programToExpr (createHeaderFile includes decls))))) + +-- | Wrap a type expression with a const qualifier +toConstType :: Syntax.TypeExpression -> Syntax.TypeExpression +toConstType baseType = + Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = baseType, + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst}) + +-- | Create an unnamed parameter (for operator overloads, etc.) +unnamedParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter +unnamedParameter name typ = + Syntax.Parameter { + Syntax.parameterType = typ, + Syntax.parameterName = name, + Syntax.parameterUnnamed = True, + Syntax.parameterDefaultValue = Nothing} + +-- | Construct a variant class name (e.g. "MyType" + "field" -> "MyTypeField") +variantName :: Model.Name -> Model.Name -> String +variantName tname fname = + sanitizeCppName (Strings.concat2 (Names.localNameOf tname) (Formatting.capitalize (Model.unName fname))) + +-- | Construct a visitor interface name +visitorName :: Model.Name -> String +visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor") diff --git a/src/main/haskell/Hydra/Ext/Cpp/Environment.hs b/src/main/haskell/Hydra/Ext/Cpp/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Environment.hs @@ -0,0 +1,28 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Type definitions for C++ code generation environment + +module Hydra.Ext.Cpp.Environment where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Environment for C++ code generation +data CppEnvironment = + CppEnvironment { + -- | ModuleName mapping for code generation + cppEnvironmentNamespaces :: (Util.ModuleNames String), + -- | Type variables in scope, with their C++ names + cppEnvironmentBoundTypeVariables :: ([Model.Name], (M.Map Model.Name String))} + deriving (Eq, Ord, Read, Show) + +_CppEnvironment = Model.Name "hydra.ext.cpp.environment.CppEnvironment" + +_CppEnvironment_namespaces = Model.Name "namespaces" + +_CppEnvironment_boundTypeVariables = Model.Name "boundTypeVariables" diff --git a/src/main/haskell/Hydra/Ext/Cpp/Language.hs b/src/main/haskell/Hydra/Ext/Cpp/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Language.hs @@ -0,0 +1,277 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints and reserved words for C++ + +module Hydra.Ext.Cpp.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | Language constraints for C++ +cppLanguage :: Coders.Language +cppLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.cpp"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "cpp")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBinary, + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = + Sets.fromList [ + Model.FloatTypeFloat32, + Model.FloatTypeFloat64] + integerTypes = + Sets.fromList [ + Model.IntegerTypeInt8, + Model.IntegerTypeInt16, + Model.IntegerTypeInt32, + Model.IntegerTypeInt64, + Model.IntegerTypeBigint] + termVariants = + Sets.fromList [ + Variants.TermVariantApplication, + Variants.TermVariantEither, + Variants.TermVariantCases, + Variants.TermVariantLambda, + Variants.TermVariantProject, + Variants.TermVariantUnwrap, + Variants.TermVariantTypeApplication, + Variants.TermVariantTypeLambda, + Variants.TermVariantLet, + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantMap, + Variants.TermVariantOptional, + Variants.TermVariantPair, + Variants.TermVariantRecord, + Variants.TermVariantSet, + Variants.TermVariantInject, + Variants.TermVariantVariable, + Variants.TermVariantWrap] + typeVariants = + Sets.fromList [ + Variants.TypeVariantApplication, + Variants.TypeVariantEither, + Variants.TypeVariantFunction, + Variants.TypeVariantForall, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantOptional, + Variants.TypeVariantPair, + Variants.TypeVariantRecord, + Variants.TypeVariantSet, + Variants.TypeVariantUnion, + Variants.TypeVariantVariable, + Variants.TypeVariantWrap] + typePredicate = \_ -> True + +-- | A set of reserved words in C++ +cppReservedWords :: S.Set String +cppReservedWords = + Sets.fromList (Lists.concat [ + cppKeywords, + cppPreprocessor, + cppStlTypes, + hydraCppKeywords]) + where + cppKeywords = + [ + "alignas", + "alignof", + "and", + "and_eq", + "asm", + "auto", + "bitand", + "bitor", + "bool", + "break", + "case", + "catch", + "char", + "char8_t", + "char16_t", + "char32_t", + "class", + "compl", + "concept", + "const", + "consteval", + "constexpr", + "constinit", + "const_cast", + "continue", + "co_await", + "co_return", + "co_yield", + "decltype", + "default", + "delete", + "do", + "double", + "dynamic_cast", + "else", + "enum", + "explicit", + "export", + "extern", + "false", + "float", + "for", + "friend", + "goto", + "if", + "inline", + "int", + "long", + "mutable", + "namespace", + "new", + "noexcept", + "not", + "not_eq", + "nullptr", + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "register", + "reinterpret_cast", + "requires", + "return", + "short", + "signed", + "sizeof", + "static", + "static_assert", + "static_cast", + "struct", + "switch", + "template", + "this", + "thread_local", + "throw", + "true", + "try", + "typedef", + "typeid", + "typename", + "union", + "unsigned", + "using", + "virtual", + "void", + "volatile", + "wchar_t", + "while", + "xor", + "xor_eq"] + cppPreprocessor = + [ + "#define", + "#elif", + "#else", + "#endif", + "#error", + "#if", + "#ifdef", + "#ifndef", + "#include", + "#line", + "#pragma", + "#undef"] + cppStlTypes = + [ + "std", + "string", + "vector", + "map", + "set", + "optional", + "variant", + "pair", + "tuple", + "function", + "array", + "deque", + "forward_list", + "list", + "multimap", + "multiset", + "unordered_map", + "unordered_set", + "unordered_multimap", + "unordered_multiset", + "stack", + "queue", + "priority_queue", + "shared_ptr", + "unique_ptr", + "weak_ptr"] + hydraCppKeywords = [] diff --git a/src/main/haskell/Hydra/Ext/Cpp/Names.hs b/src/main/haskell/Hydra/Ext/Cpp/Names.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Names.hs @@ -0,0 +1,150 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | C++ naming utilities: encoding Hydra names as C++ names + +module Hydra.Ext.Cpp.Names where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Cpp.Environment as Environment +import qualified Hydra.Ext.Cpp.Language as Language +import qualified Hydra.Ext.Cpp.Syntax as Syntax +import qualified Hydra.Ext.Cpp.Utils as Utils +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Get the C++ class name from a Hydra Name +className :: Model.Name -> String +className name = sanitizeCppName (Names.localNameOf name) + +-- | Create a type reference, optionally wrapped in shared_ptr +createTypeReference :: Bool -> Environment.CppEnvironment -> Model.Name -> Syntax.TypeExpression +createTypeReference isPointer env name = + + let baseType = Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (encodeName True Util.CaseConventionPascal env name)) + in (Logic.ifElse isPointer (Utils.toConstType baseType) baseType) + +-- | Encode an enum value with appropriate naming convention +encodeEnumValue :: Environment.CppEnvironment -> Model.Name -> String +encodeEnumValue = encodeName False Util.CaseConventionUpperSnake + +-- | Encode a field name with appropriate naming convention +encodeFieldName :: Environment.CppEnvironment -> Model.Name -> String +encodeFieldName env fname = encodeName False Util.CaseConventionLowerSnake env fname + +-- | Encode a name with specified convention +encodeName :: Bool -> Util.CaseConvention -> Environment.CppEnvironment -> Model.Name -> String +encodeName isQualified conv env name = + + let focusNs = Pairs.first (Util.moduleNamesFocus (Environment.cppEnvironmentNamespaces env)) + boundVars = Pairs.second (Environment.cppEnvironmentBoundTypeVariables env) + qualName = Names.qualifyName name + mns = Util.qualifiedNameModuleName qualName + local = Util.qualifiedNameLocal qualName + cppLocal = sanitizeCppName (Formatting.convertCase Util.CaseConventionCamel conv local) + cppNs = + \nsVal -> Strings.join "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal))) + in (Logic.ifElse isQualified (Optionals.match (Maps.lookup name boundVars) (Optionals.match mns cppLocal (\nsVal -> Strings.concat2 (cppNs nsVal) (Strings.concat2 "::" cppLocal))) (\n -> n)) cppLocal) + +-- | Encode a qualified name with namespace +encodeNameQualified :: Environment.CppEnvironment -> Model.Name -> String +encodeNameQualified env name = + + let boundVars = Pairs.second (Environment.cppEnvironmentBoundTypeVariables env) + focusNs = Pairs.first (Util.moduleNamesFocus (Environment.cppEnvironmentNamespaces env)) + qualName = Names.qualifyName name + mns = Util.qualifiedNameModuleName qualName + local = Util.qualifiedNameLocal qualName + in (Optionals.match (Maps.lookup name boundVars) (Logic.ifElse (Equality.equal mns (Just focusNs)) (sanitizeCppName local) (Strings.join "::" (Lists.map sanitizeCppName (Strings.splitOn "." (Model.unName name))))) (\n -> n)) + +-- | Encode a namespace as a C++ namespace string +encodeNamespace :: Packaging.ModuleName -> String +encodeNamespace nsVal = + Strings.join "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal))) + +-- | Encode a type variable name +encodeTypeVariable :: Model.Name -> String +encodeTypeVariable name = Formatting.capitalize (Model.unName name) + +-- | Get the forward header name for a namespace +fwdHeaderName :: Packaging.ModuleName -> Model.Name +fwdHeaderName nsVal = + Names.unqualifyName (Util.QualifiedName { + Util.qualifiedNameModuleName = (Just nsVal), + Util.qualifiedNameLocal = "Fwd"}) + +-- | Create a namespace declaration wrapping inner declarations +namespaceDecl :: Packaging.ModuleName -> [Syntax.Declaration] -> Syntax.Declaration +namespaceDecl nsVal decls = + Syntax.DeclarationNamespace (Syntax.NamespaceDeclaration { + Syntax.namespaceDeclarationName = (encodeNamespace nsVal), + Syntax.namespaceDeclarationDeclarations = decls}) + +-- | Get the partial visitor name for a type +partialVisitorName :: Model.Name -> String +partialVisitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "PartialVisitor") + +-- | Sanitize a name to be valid in C++ +sanitizeCppName :: String -> String +sanitizeCppName = Formatting.sanitizeWithUnderscores Language.cppReservedWords + +-- | Create a reference to a term variable +termVariableReference :: Environment.CppEnvironment -> Model.Name -> Syntax.Expression +termVariableReference = variableReference Util.CaseConventionLowerSnake + +-- | Create a reference to a type variable +typeVariableReference :: Environment.CppEnvironment -> Model.Name -> Syntax.TypeExpression +typeVariableReference env name = + Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (encodeName True Util.CaseConventionPascal env name)) + +-- | Create a variable reference expression +variableReference :: Util.CaseConvention -> Environment.CppEnvironment -> Model.Name -> Syntax.Expression +variableReference conv env name = Utils.createIdentifierExpr (encodeName True conv env name) + +-- | Get the variant name by combining type name and field name +variantName :: Model.Name -> Model.Name -> String +variantName tname fname = + sanitizeCppName (Strings.concat2 (Names.localNameOf tname) (Formatting.capitalize (Model.unName fname))) + +-- | Get the visitor name for a type +visitorName :: Model.Name -> String +visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor") diff --git a/src/main/haskell/Hydra/Ext/Cpp/Serde.hs b/src/main/haskell/Hydra/Ext/Cpp/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Serde.hs @@ -0,0 +1,1356 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Serialization functions for converting C++ AST to abstract expressions + +module Hydra.Ext.Cpp.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Cpp.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Convert an access specifier to an expression +accessSpecifierToExpr :: Syntax.AccessSpecifier -> Ast.Expr +accessSpecifierToExpr a = + case a of + Syntax.AccessSpecifierPublic -> Serialization.cst "public" + Syntax.AccessSpecifierProtected -> Serialization.cst "protected" + Syntax.AccessSpecifierPrivate -> Serialization.cst "private" + Syntax.AccessSpecifierNone -> Serialization.cst "" + +-- | Convert an add operation to an expression +addOperationToExpr :: Syntax.AddOperation -> Ast.Expr +addOperationToExpr op = + + let left = Syntax.addOperationLeft op + right = Syntax.addOperationRight op + in (Serialization.spaceSep [ + additiveExpressionToExpr left, + (Serialization.cst "+"), + (multiplicativeExpressionToExpr right)]) + +-- | Convert an additive expression to an expression +additiveExpressionToExpr :: Syntax.AdditiveExpression -> Ast.Expr +additiveExpressionToExpr e = + case e of + Syntax.AdditiveExpressionMultiplicative v0 -> multiplicativeExpressionToExpr v0 + Syntax.AdditiveExpressionAdd v0 -> addOperationToExpr v0 + Syntax.AdditiveExpressionSubtract v0 -> subtractOperationToExpr v0 + +-- | Convert an and expression to an expression +andExpressionToExpr :: Syntax.AndExpression -> Ast.Expr +andExpressionToExpr e = + case e of + Syntax.AndExpressionEquality v0 -> equalityExpressionToExpr v0 + Syntax.AndExpressionBitwiseAnd v0 -> bitwiseAndOperationToExpr v0 + +-- | Convert an assignment expression to an expression +assignmentExpressionToExpr :: Syntax.AssignmentExpression -> Ast.Expr +assignmentExpressionToExpr a = + case a of + Syntax.AssignmentExpressionConditional v0 -> conditionalExpressionToExpr v0 + Syntax.AssignmentExpressionAssignment v0 -> explicitAssignmentToExpr v0 + +-- | Convert an assignment operator to an expression +assignmentOperatorToExpr :: Syntax.AssignmentOperator -> Ast.Expr +assignmentOperatorToExpr op = + case op of + Syntax.AssignmentOperatorAssign -> Serialization.cst "=" + Syntax.AssignmentOperatorPlusAssign -> Serialization.cst "+=" + Syntax.AssignmentOperatorMinusAssign -> Serialization.cst "-=" + Syntax.AssignmentOperatorMultiplyAssign -> Serialization.cst "*=" + Syntax.AssignmentOperatorDivideAssign -> Serialization.cst "/=" + Syntax.AssignmentOperatorModuloAssign -> Serialization.cst "%=" + Syntax.AssignmentOperatorLeftShiftAssign -> Serialization.cst "<<=" + Syntax.AssignmentOperatorRightShiftAssign -> Serialization.cst ">>=" + Syntax.AssignmentOperatorBitwiseAndAssign -> Serialization.cst "&=" + Syntax.AssignmentOperatorBitwiseXorAssign -> Serialization.cst "^=" + Syntax.AssignmentOperatorBitwiseOrAssign -> Serialization.cst "|=" + +-- | Convert a base specifier to an expression +baseSpecifierToExpr :: Syntax.BaseSpecifier -> Ast.Expr +baseSpecifierToExpr bs = + + let access = Syntax.baseSpecifierAccess bs + name = Syntax.baseSpecifierName bs + in (Serialization.spaceSep [ + accessSpecifierToExpr access, + (Serialization.cst name)]) + +-- | Convert a basic type to an expression +basicTypeToExpr :: Syntax.BasicType -> Ast.Expr +basicTypeToExpr t = + case t of + Syntax.BasicTypeVoid -> Serialization.cst "void" + Syntax.BasicTypeBool -> Serialization.cst "bool" + Syntax.BasicTypeChar -> Serialization.cst "char" + Syntax.BasicTypeInt -> Serialization.cst "int" + Syntax.BasicTypeFloat -> Serialization.cst "float" + Syntax.BasicTypeDouble -> Serialization.cst "double" + Syntax.BasicTypeString -> Serialization.cst "std::string" + Syntax.BasicTypeAuto -> Serialization.cst "auto" + Syntax.BasicTypeNamed v0 -> Serialization.cst v0 + +-- | Convert a bitwise and operation to an expression +bitwiseAndOperationToExpr :: Syntax.BitwiseAndOperation -> Ast.Expr +bitwiseAndOperationToExpr op = + + let left = Syntax.bitwiseAndOperationLeft op + right = Syntax.bitwiseAndOperationRight op + in (Serialization.spaceSep [ + andExpressionToExpr left, + (Serialization.cst "&"), + (equalityExpressionToExpr right)]) + +-- | Convert a bitwise or operation to an expression +bitwiseOrOperationToExpr :: Syntax.BitwiseOrOperation -> Ast.Expr +bitwiseOrOperationToExpr op = + + let left = Syntax.bitwiseOrOperationLeft op + right = Syntax.bitwiseOrOperationRight op + in (Serialization.spaceSep [ + inclusiveOrExpressionToExpr left, + (Serialization.cst "|"), + (exclusiveOrExpressionToExpr right)]) + +-- | Convert a bitwise xor operation to an expression +bitwiseXorOperationToExpr :: Syntax.BitwiseXorOperation -> Ast.Expr +bitwiseXorOperationToExpr op = + + let left = Syntax.bitwiseXorOperationLeft op + right = Syntax.bitwiseXorOperationRight op + in (Serialization.spaceSep [ + exclusiveOrExpressionToExpr left, + (Serialization.cst "^"), + (andExpressionToExpr right)]) + +-- | Convert a boolean literal to an expression +booleanLiteralToExpr :: Syntax.BooleanLiteral -> Ast.Expr +booleanLiteralToExpr bl = Logic.ifElse (Syntax.unBooleanLiteral bl) (Serialization.cst "true") (Serialization.cst "false") + +-- | Convert a capture list to an expression +captureListToExpr :: Syntax.CaptureList -> Ast.Expr +captureListToExpr cl = + case cl of + Syntax.CaptureListCaptureByValue -> Serialization.cst "[=]" + Syntax.CaptureListCaptures v0 -> Serialization.bracketList Serialization.inlineStyle (Lists.map captureToExpr v0) + +-- | Convert a capture to an expression +captureToExpr :: Syntax.Capture -> Ast.Expr +captureToExpr cap = + + let name = Syntax.captureName cap + byRef = Syntax.captureByReference cap + in (Logic.ifElse byRef (Serialization.cst (Strings.concat2 "&" name)) (Serialization.cst name)) + +-- | Convert a case statement to an expression +caseStatementToExpr :: Syntax.CaseStatement -> Ast.Expr +caseStatementToExpr stmt = + case stmt of + Syntax.CaseStatementCase v0 -> caseValueToExpr v0 + Syntax.CaseStatementDefault v0 -> Serialization.spaceSep [ + Serialization.cst "default:", + (statementToExpr v0)] + +-- | Convert a case value to an expression +caseValueToExpr :: Syntax.CaseValue -> Ast.Expr +caseValueToExpr cv = + + let value = Syntax.caseValueValue cv + statement = Syntax.caseValueStatement cv + in (Serialization.spaceSep [ + Serialization.cst "case", + (Serialization.noSep [ + expressionToExpr value, + (Serialization.cst ":")]), + (statementToExpr statement)]) + +-- | Convert a class body to an expression +classBodyToExpr :: Bool -> Syntax.ClassBody -> Ast.Expr +classBodyToExpr commas cb = + Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map (memberSpecificationToExpr commas) (Syntax.unClassBody cb))) + +-- | Convert a class declaration to an expression +classDeclarationToExpr :: Syntax.ClassDeclaration -> Ast.Expr +classDeclarationToExpr cd = + + let spec = Syntax.classDeclarationSpecifier cd + mbody = Syntax.classDeclarationBody cd + key = Syntax.classSpecifierKey spec + isEnum = Logic.or (Equality.equal key Syntax.ClassKeyEnum) (Equality.equal key Syntax.ClassKeyEnumClass) + in (Serialization.withSemi (Serialization.spaceSep (Optionals.givens [ + Just (classSpecifierToExpr spec), + (Optionals.map (\body -> classBodyToExpr isEnum body) mbody)]))) + +-- | Convert a class key to an expression +classKeyToExpr :: Syntax.ClassKey -> Ast.Expr +classKeyToExpr k = + case k of + Syntax.ClassKeyClass -> Serialization.cst "class" + Syntax.ClassKeyEnum -> Serialization.cst "enum" + Syntax.ClassKeyEnumClass -> Serialization.cst "enum class" + Syntax.ClassKeyStruct -> Serialization.cst "struct" + +-- | Convert a class specifier to an expression +classSpecifierToExpr :: Syntax.ClassSpecifier -> Ast.Expr +classSpecifierToExpr cs = + + let key = Syntax.classSpecifierKey cs + name = Syntax.classSpecifierName cs + inheritance = Syntax.classSpecifierInheritance cs + in (Serialization.spaceSep (Lists.concat [ + [ + classKeyToExpr key, + (Serialization.cst name)], + (Logic.ifElse (Lists.isEmpty inheritance) [] [ + Serialization.cst ":", + (Serialization.commaSep Serialization.inlineStyle (Lists.map baseSpecifierToExpr inheritance))])])) + +-- | Convert a comma expression to an expression +commaExpressionToExpr :: Syntax.CommaExpression -> Ast.Expr +commaExpressionToExpr ce = + + let left = Syntax.commaExpressionLeft ce + right = Syntax.commaExpressionRight ce + in (Serialization.spaceSep [ + expressionToExpr left, + (Serialization.cst ","), + (assignmentExpressionToExpr right)]) + +-- | Convert a comment to an expression +commentToExpr :: Syntax.Comment -> Ast.Expr +commentToExpr c = + + let text = Syntax.commentText c + isMultiline = Syntax.commentIsMultiline c + in (Serialization.cst (toCppComments text isMultiline)) + +-- | Convert a compound statement to an expression +compoundStatementToExpr :: Syntax.CompoundStatement -> Ast.Expr +compoundStatementToExpr cs = + Serialization.curlyBracesList (Just "") Serialization.fullBlockStyle (Lists.map statementToExpr (Syntax.unCompoundStatement cs)) + +-- | Convert a conditional expression to an expression +conditionalExpressionToExpr :: Syntax.ConditionalExpression -> Ast.Expr +conditionalExpressionToExpr c = + case c of + Syntax.ConditionalExpressionLogicalOr v0 -> logicalOrExpressionToExpr v0 + Syntax.ConditionalExpressionTernary v0 -> ternaryExpressionToExpr v0 + +-- | Convert a constructor declaration to an expression +constructorDeclarationToExpr :: Syntax.ConstructorDeclaration -> Ast.Expr +constructorDeclarationToExpr cd = + + let name = Syntax.constructorDeclarationName cd + params = Syntax.constructorDeclarationParameters cd + inits = Syntax.constructorDeclarationInitializers cd + body = Syntax.constructorDeclarationBody cd + in (Serialization.spaceSep (Optionals.givens [ + Just (Serialization.noSep [ + Serialization.cst name, + (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]), + (Logic.ifElse (Lists.isEmpty inits) Nothing (Just (Serialization.spaceSep [ + Serialization.cst ":", + (Serialization.commaSep Serialization.inlineStyle (Lists.map memInitializerToExpr inits))]))), + (Just (functionBodyToExpr body))])) + +-- | Convert a declaration to an expression +declarationToExpr :: Syntax.Declaration -> Ast.Expr +declarationToExpr d = + case d of + Syntax.DeclarationPreprocessor v0 -> preprocessorDirectiveToExpr v0 + Syntax.DeclarationClass v0 -> classDeclarationToExpr v0 + Syntax.DeclarationFunction v0 -> functionDeclarationToExpr v0 + Syntax.DeclarationVariable v0 -> variableDeclarationToExpr False v0 + Syntax.DeclarationTypedef v0 -> typedefDeclarationToExpr v0 + Syntax.DeclarationNamespace v0 -> namespaceDeclarationToExpr v0 + Syntax.DeclarationTemplate v0 -> templateDeclarationToExpr v0 + +-- | Convert a define directive to an expression +defineDirectiveToExpr :: Syntax.DefineDirective -> Ast.Expr +defineDirectiveToExpr dd = + + let name = Syntax.defineDirectiveName dd + params = Syntax.defineDirectiveParameters dd + replacement = Syntax.defineDirectiveReplacement dd + in (Serialization.spaceSep (Lists.concat [ + [ + Serialization.cst "#define", + (Serialization.cst name)], + (Optionals.match params [] (\ps -> [ + Serialization.parenListAdaptive (Lists.map (\p -> Serialization.cst p) ps)])), + (Optionals.match replacement [] (\r -> [ + Serialization.cst r]))])) + +-- | Convert a destructor declaration to an expression +destructorDeclarationToExpr :: Syntax.DestructorDeclaration -> Ast.Expr +destructorDeclarationToExpr dd = + + let prefixSpecs = Syntax.destructorDeclarationPrefixSpecifiers dd + name = Syntax.destructorDeclarationName dd + suffixSpecs = Syntax.destructorDeclarationSuffixSpecifiers dd + body = Syntax.destructorDeclarationBody dd + in (Serialization.spaceSep (Lists.concat [ + Lists.map functionSpecifierPrefixToExpr prefixSpecs, + [ + Serialization.noSep [ + Serialization.cst (Strings.concat2 "~" name), + (Serialization.parens (Serialization.cst ""))]], + (Lists.map functionSpecifierSuffixToExpr suffixSpecs), + [ + functionBodyToExpr body]])) + +-- | Convert a divide operation to an expression +divideOperationToExpr :: Syntax.DivideOperation -> Ast.Expr +divideOperationToExpr op = + + let left = Syntax.divideOperationLeft op + right = Syntax.divideOperationRight op + in (Serialization.spaceSep [ + multiplicativeExpressionToExpr left, + (Serialization.cst "/"), + (unaryExpressionToExpr right)]) + +-- | Convert a do statement to an expression +doStatementToExpr :: Syntax.DoStatement -> Ast.Expr +doStatementToExpr ds = + + let body = Syntax.doStatementBody ds + cond = Syntax.doStatementCondition ds + in (Serialization.newlineSep [ + Serialization.cst "do", + (statementToExpr body), + (Serialization.withSemi (Serialization.spaceSep [ + Serialization.cst "while", + (Serialization.parens (expressionToExpr cond))]))]) + +-- | Convert an elif directive to an expression +elifDirectiveToExpr :: Syntax.ElifDirective -> Ast.Expr +elifDirectiveToExpr ed = + Serialization.spaceSep [ + Serialization.cst "#elif", + (Serialization.cst (Syntax.elifDirectiveCondition ed))] + +-- | Convert an else directive to an expression +elseDirectiveToExpr :: t0 -> Ast.Expr +elseDirectiveToExpr ed = Serialization.cst "#else" + +-- | Convert an endif directive to an expression +endifDirectiveToExpr :: t0 -> Ast.Expr +endifDirectiveToExpr ed = Serialization.cst "#endif" + +-- | Convert an equal operation to an expression +equalOperationToExpr :: Syntax.EqualOperation -> Ast.Expr +equalOperationToExpr op = + + let left = Syntax.equalOperationLeft op + right = Syntax.equalOperationRight op + in (Serialization.spaceSep [ + equalityExpressionToExpr left, + (Serialization.cst "=="), + (relationalExpressionToExpr right)]) + +-- | Convert an equality expression to an expression +equalityExpressionToExpr :: Syntax.EqualityExpression -> Ast.Expr +equalityExpressionToExpr e = + case e of + Syntax.EqualityExpressionRelational v0 -> relationalExpressionToExpr v0 + Syntax.EqualityExpressionEqual v0 -> equalOperationToExpr v0 + Syntax.EqualityExpressionNotEqual v0 -> notEqualOperationToExpr v0 + +-- | Convert an error directive to an expression +errorDirectiveToExpr :: Syntax.ErrorDirective -> Ast.Expr +errorDirectiveToExpr ed = + Serialization.spaceSep [ + Serialization.cst "#error", + (Serialization.cst (Syntax.errorDirectiveMessage ed))] + +-- | Convert an exclusive or expression to an expression +exclusiveOrExpressionToExpr :: Syntax.ExclusiveOrExpression -> Ast.Expr +exclusiveOrExpressionToExpr e = + case e of + Syntax.ExclusiveOrExpressionAnd v0 -> andExpressionToExpr v0 + Syntax.ExclusiveOrExpressionBitwiseXor v0 -> bitwiseXorOperationToExpr v0 + +-- | Convert an explicit assignment to an expression +explicitAssignmentToExpr :: Syntax.ExplicitAssignment -> Ast.Expr +explicitAssignmentToExpr ea = + + let left = Syntax.explicitAssignmentLeft ea + op = Syntax.explicitAssignmentOp ea + right = Syntax.explicitAssignmentRight ea + in (Serialization.spaceSep [ + logicalOrExpressionToExpr left, + (assignmentOperatorToExpr op), + (assignmentExpressionToExpr right)]) + +-- | Convert an expression to an expression +expressionToExpr :: Syntax.Expression -> Ast.Expr +expressionToExpr e = + case e of + Syntax.ExpressionAssignment v0 -> assignmentExpressionToExpr v0 + Syntax.ExpressionComma v0 -> commaExpressionToExpr v0 + +-- | Convert a for-init to an expression +forInitToExpr :: Syntax.ForInit -> Ast.Expr +forInitToExpr i = + case i of + Syntax.ForInitExpression v0 -> expressionToExpr v0 + Syntax.ForInitDeclaration v0 -> variableDeclarationToExpr False v0 + Syntax.ForInitEmpty -> Serialization.cst "" + +-- | Convert a for statement to an expression +forStatementToExpr :: Syntax.ForStatement -> Ast.Expr +forStatementToExpr fs = + + let init = Syntax.forStatementInit fs + cond = Syntax.forStatementCondition fs + inc = Syntax.forStatementIncrement fs + body = Syntax.forStatementBody fs + in (Serialization.newlineSep [ + Serialization.spaceSep [ + Serialization.cst "for", + (Serialization.parens (Serialization.noSep [ + forInitToExpr init, + (Serialization.cst ";"), + (expressionToExpr cond), + (Serialization.cst ";"), + (expressionToExpr inc)]))], + (statementToExpr body)]) + +-- | Convert a function application to an expression +functionApplicationToExpr :: Syntax.FunctionApplication -> Ast.Expr +functionApplicationToExpr fa = + + let func = Syntax.functionApplicationFunction fa + args = Syntax.functionApplicationArguments fa + in (Serialization.spaceSep [ + functionIdentifierToExpr func, + (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) + +-- | Convert a function body to an expression +functionBodyToExpr :: Syntax.FunctionBody -> Ast.Expr +functionBodyToExpr b = + case b of + Syntax.FunctionBodyCompound v0 -> compoundStatementToExpr v0 + Syntax.FunctionBodyDeclaration -> Serialization.cst ";" + Syntax.FunctionBodyPure -> Serialization.withSemi (Serialization.cst "= 0") + Syntax.FunctionBodyDefault -> Serialization.withSemi (Serialization.cst "= default") + +-- | Convert a function call operation to an expression +functionCallOperationToExpr :: Syntax.FunctionCallOperation -> Ast.Expr +functionCallOperationToExpr fco = + + let func = Syntax.functionCallOperationFunction fco + args = Syntax.functionCallOperationArguments fco + in (Serialization.noSep [ + postfixExpressionToExpr func, + (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) + +-- | Convert a function declaration to an expression +functionDeclarationToExpr :: Syntax.FunctionDeclaration -> Ast.Expr +functionDeclarationToExpr fd = + + let prefixSpecs = Syntax.functionDeclarationPrefixSpecifiers fd + retType = Syntax.functionDeclarationReturnType fd + name = Syntax.functionDeclarationName fd + params = Syntax.functionDeclarationParameters fd + suffixSpecs = Syntax.functionDeclarationSuffixSpecifiers fd + body = Syntax.functionDeclarationBody fd + in (Serialization.spaceSep (Lists.concat [ + Lists.map functionSpecifierPrefixToExpr prefixSpecs, + [ + typeExpressionToExpr retType, + (Serialization.noSep [ + Serialization.cst name, + (Serialization.parenListAdaptive (Lists.map parameterToExpr params))])], + (Lists.map functionSpecifierSuffixToExpr suffixSpecs), + [ + functionBodyToExpr body]])) + +-- | Convert a function identifier to an expression +functionIdentifierToExpr :: Syntax.FunctionIdentifier -> Ast.Expr +functionIdentifierToExpr f = + case f of + Syntax.FunctionIdentifierSimple v0 -> Serialization.cst v0 + Syntax.FunctionIdentifierQualified v0 -> qualifiedIdentifierToExpr v0 + +-- | Convert a function specifier prefix to an expression +functionSpecifierPrefixToExpr :: Syntax.FunctionSpecifierPrefix -> Ast.Expr +functionSpecifierPrefixToExpr s = + case s of + Syntax.FunctionSpecifierPrefixInline -> Serialization.cst "inline" + Syntax.FunctionSpecifierPrefixVirtual -> Serialization.cst "virtual" + Syntax.FunctionSpecifierPrefixStatic -> Serialization.cst "static" + Syntax.FunctionSpecifierPrefixExplicit -> Serialization.cst "explicit" + +-- | Convert a function specifier suffix to an expression +functionSpecifierSuffixToExpr :: Syntax.FunctionSpecifierSuffix -> Ast.Expr +functionSpecifierSuffixToExpr s = + case s of + Syntax.FunctionSpecifierSuffixConst -> Serialization.cst "const" + Syntax.FunctionSpecifierSuffixNoexcept -> Serialization.cst "noexcept" + Syntax.FunctionSpecifierSuffixOverride -> Serialization.cst "override" + Syntax.FunctionSpecifierSuffixFinal -> Serialization.cst "final" + +-- | Convert a function type to an expression +functionTypeToExpr :: Syntax.FunctionType -> Ast.Expr +functionTypeToExpr ft = + + let retType = Syntax.functionTypeReturnType ft + params = Syntax.functionTypeParameters ft + in (Serialization.spaceSep [ + typeExpressionToExpr retType, + (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]) + +-- | Convert a greater-than-or-equal operation to an expression +greaterEqualOperationToExpr :: Syntax.GreaterEqualOperation -> Ast.Expr +greaterEqualOperationToExpr op = + + let left = Syntax.greaterEqualOperationLeft op + right = Syntax.greaterEqualOperationRight op + in (Serialization.spaceSep [ + relationalExpressionToExpr left, + (Serialization.cst ">="), + (shiftExpressionToExpr right)]) + +-- | Convert a greater-than operation to an expression +greaterOperationToExpr :: Syntax.GreaterOperation -> Ast.Expr +greaterOperationToExpr op = + + let left = Syntax.greaterOperationLeft op + right = Syntax.greaterOperationRight op + in (Serialization.spaceSep [ + relationalExpressionToExpr left, + (Serialization.cst ">"), + (shiftExpressionToExpr right)]) + +-- | Convert an if directive to an expression +ifDirectiveToExpr :: Syntax.IfDirective -> Ast.Expr +ifDirectiveToExpr ifd = + Serialization.spaceSep [ + Serialization.cst "#if", + (Serialization.cst (Syntax.ifDirectiveCondition ifd))] + +-- | Convert an ifdef directive to an expression +ifdefDirectiveToExpr :: Syntax.IfdefDirective -> Ast.Expr +ifdefDirectiveToExpr id = + Serialization.spaceSep [ + Serialization.cst "#ifdef", + (Serialization.cst (Syntax.ifdefDirectiveIdentifier id))] + +-- | Convert an ifndef directive to an expression +ifndefDirectiveToExpr :: Syntax.IfndefDirective -> Ast.Expr +ifndefDirectiveToExpr ind = + Serialization.spaceSep [ + Serialization.cst "#ifndef", + (Serialization.cst (Syntax.ifndefDirectiveIdentifier ind))] + +-- | Convert an include directive to an expression +includeDirectiveToExpr :: Syntax.IncludeDirective -> Ast.Expr +includeDirectiveToExpr incl = + + let name = Syntax.includeDirectiveName incl + isSystem = Syntax.includeDirectiveIsSystem incl + in (Logic.ifElse isSystem (Serialization.cst (Strings.concat [ + "#include <", + name, + ">"])) (Serialization.cst (Strings.concat [ + "#include \"", + name, + "\""]))) + +-- | Convert an inclusive or expression to an expression +inclusiveOrExpressionToExpr :: Syntax.InclusiveOrExpression -> Ast.Expr +inclusiveOrExpressionToExpr e = + case e of + Syntax.InclusiveOrExpressionExclusiveOr v0 -> exclusiveOrExpressionToExpr v0 + Syntax.InclusiveOrExpressionBitwiseOr v0 -> bitwiseOrOperationToExpr v0 + +-- | Convert an integer literal to an expression +integerLiteralToExpr :: Syntax.IntegerLiteral -> Ast.Expr +integerLiteralToExpr i = + case i of + Syntax.IntegerLiteralDecimal v0 -> Serialization.cst (Literals.printBigint v0) + Syntax.IntegerLiteralHexadecimal v0 -> Serialization.cst (Strings.concat2 "0x" v0) + Syntax.IntegerLiteralOctal v0 -> Serialization.cst (Strings.concat2 "0" v0) + Syntax.IntegerLiteralBinary v0 -> Serialization.cst (Strings.concat2 "0b" v0) + +-- | Convert an iteration statement to an expression +iterationStatementToExpr :: Syntax.IterationStatement -> Ast.Expr +iterationStatementToExpr i = + case i of + Syntax.IterationStatementWhile v0 -> whileStatementToExpr v0 + Syntax.IterationStatementDo v0 -> doStatementToExpr v0 + Syntax.IterationStatementFor v0 -> forStatementToExpr v0 + Syntax.IterationStatementRangeFor v0 -> rangeForStatementToExpr v0 + +-- | Convert a jump statement to an expression +jumpStatementToExpr :: Syntax.JumpStatement -> Ast.Expr +jumpStatementToExpr j = + case j of + Syntax.JumpStatementBreak -> Serialization.withSemi (Serialization.cst "break") + Syntax.JumpStatementContinue -> Serialization.withSemi (Serialization.cst "continue") + Syntax.JumpStatementReturnValue v0 -> Serialization.withSemi (Serialization.spaceSep [ + Serialization.cst "return", + (expressionToExpr v0)]) + Syntax.JumpStatementReturnVoid -> Serialization.withSemi (Serialization.cst "return") + Syntax.JumpStatementThrow v0 -> Serialization.withSemi (Serialization.spaceSep [ + Serialization.cst "throw", + (expressionToExpr v0)]) + +-- | Convert a labeled statement to an expression +labeledStatementToExpr :: Syntax.LabeledStatement -> Ast.Expr +labeledStatementToExpr ls = + + let label = Syntax.labeledStatementLabel ls + stmt = Syntax.labeledStatementStatement ls + in (Serialization.newlineSep [ + Serialization.cst (Strings.concat2 label ":"), + (statementToExpr stmt)]) + +-- | Convert a lambda expression to an expression +lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr +lambdaExpressionToExpr le = + + let captures = Syntax.lambdaExpressionCaptures le + params = Syntax.lambdaExpressionParameters le + retType = Syntax.lambdaExpressionReturnType le + body = Syntax.lambdaExpressionBody le + in (Serialization.spaceSep [ + captureListToExpr captures, + (Logic.ifElse (Lists.isEmpty params) (Serialization.parens (Serialization.cst "")) (Serialization.parenListAdaptive (Lists.map parameterToExpr params))), + (Optionals.match retType (Serialization.cst "") (\t -> Serialization.spaceSep [ + Serialization.cst "->", + (typeExpressionToExpr t)])), + (compoundStatementToExpr body)]) + +-- | Convert a left shift operation to an expression +leftShiftOperationToExpr :: Syntax.LeftShiftOperation -> Ast.Expr +leftShiftOperationToExpr op = + + let left = Syntax.leftShiftOperationLeft op + right = Syntax.leftShiftOperationRight op + in (Serialization.spaceSep [ + shiftExpressionToExpr left, + (Serialization.cst "<<"), + (additiveExpressionToExpr right)]) + +-- | Convert a less-than-or-equal operation to an expression +lessEqualOperationToExpr :: Syntax.LessEqualOperation -> Ast.Expr +lessEqualOperationToExpr op = + + let left = Syntax.lessEqualOperationLeft op + right = Syntax.lessEqualOperationRight op + in (Serialization.spaceSep [ + relationalExpressionToExpr left, + (Serialization.cst "<="), + (shiftExpressionToExpr right)]) + +-- | Convert a less-than operation to an expression +lessOperationToExpr :: Syntax.LessOperation -> Ast.Expr +lessOperationToExpr op = + + let left = Syntax.lessOperationLeft op + right = Syntax.lessOperationRight op + in (Serialization.spaceSep [ + relationalExpressionToExpr left, + (Serialization.cst "<"), + (shiftExpressionToExpr right)]) + +-- | Convert a line directive to an expression +lineDirectiveToExpr :: Syntax.LineDirective -> Ast.Expr +lineDirectiveToExpr ld = + + let lineNumber = Syntax.lineDirectiveLineNumber ld + filename = Syntax.lineDirectiveFilename ld + in (Serialization.spaceSep (Lists.concat [ + [ + Serialization.cst "#line", + (Serialization.cst (Literals.printInt32 lineNumber))], + (Optionals.match filename [] (\f -> [ + Serialization.cst (Strings.concat [ + "\"", + f, + "\""])]))])) + +-- | Convert a literal to an expression +literalToExpr :: Syntax.Literal -> Ast.Expr +literalToExpr l = + case l of + Syntax.LiteralInteger v0 -> integerLiteralToExpr v0 + Syntax.LiteralFloating v0 -> Serialization.cst (Literals.printFloat64 (Syntax.unFloatingLiteral v0)) + Syntax.LiteralCharacter v0 -> Serialization.cst (Strings.concat [ + "'", + (Syntax.unCharacterLiteral v0), + "'"]) + Syntax.LiteralString v0 -> Serialization.cst (Strings.concat [ + "\"", + (Syntax.unStringLiteral v0), + "\""]) + Syntax.LiteralBoolean v0 -> booleanLiteralToExpr v0 + Syntax.LiteralNull -> Serialization.cst "nullptr" + +-- | Convert a logical and expression to an expression +logicalAndExpressionToExpr :: Syntax.LogicalAndExpression -> Ast.Expr +logicalAndExpressionToExpr e = + case e of + Syntax.LogicalAndExpressionInclusiveOr v0 -> inclusiveOrExpressionToExpr v0 + Syntax.LogicalAndExpressionLogicalAnd v0 -> logicalAndOperationToExpr v0 + +-- | Convert a logical and operation to an expression +logicalAndOperationToExpr :: Syntax.LogicalAndOperation -> Ast.Expr +logicalAndOperationToExpr op = + + let left = Syntax.logicalAndOperationLeft op + right = Syntax.logicalAndOperationRight op + in (Serialization.spaceSep [ + logicalAndExpressionToExpr left, + (Serialization.cst "&&"), + (inclusiveOrExpressionToExpr right)]) + +-- | Convert a logical or expression to an expression +logicalOrExpressionToExpr :: Syntax.LogicalOrExpression -> Ast.Expr +logicalOrExpressionToExpr e = + case e of + Syntax.LogicalOrExpressionLogicalAnd v0 -> logicalAndExpressionToExpr v0 + Syntax.LogicalOrExpressionLogicalOr v0 -> logicalOrOperationToExpr v0 + +-- | Convert a logical or operation to an expression +logicalOrOperationToExpr :: Syntax.LogicalOrOperation -> Ast.Expr +logicalOrOperationToExpr op = + + let left = Syntax.logicalOrOperationLeft op + right = Syntax.logicalOrOperationRight op + in (Serialization.spaceSep [ + logicalOrExpressionToExpr left, + (Serialization.cst "||"), + (logicalAndExpressionToExpr right)]) + +-- | Convert a map entry to an expression +mapEntryToExpr :: Syntax.MapEntry -> Ast.Expr +mapEntryToExpr me = + + let key = Syntax.mapEntryKey me + val = Syntax.mapEntryValue me + in (Serialization.spaceSep [ + Serialization.curlyBracesList Nothing Serialization.inlineStyle [ + expressionToExpr key], + (Serialization.cst "->"), + (expressionToExpr val)]) + +-- | Convert a map to an expression +mapToExpr :: Syntax.Map -> Ast.Expr +mapToExpr m = + + let keyType = Syntax.mapKeyType m + valType = Syntax.mapValueType m + entries = Syntax.mapEntries m + in (Serialization.spaceSep [ + Serialization.cst "std::map<", + (Serialization.commaSep Serialization.inlineStyle [ + typeExpressionToExpr keyType, + (typeExpressionToExpr valType)]), + (Serialization.cst ">"), + (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map mapEntryToExpr entries))]) + +-- | Convert a member initializer to an expression +memInitializerToExpr :: Syntax.MemInitializer -> Ast.Expr +memInitializerToExpr mi = + + let name = Syntax.memInitializerName mi + args = Syntax.memInitializerArguments mi + in (Serialization.noSep [ + Serialization.cst name, + (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) + +-- | Convert a member access operation to an expression +memberAccessOperationToExpr :: Syntax.MemberAccessOperation -> Ast.Expr +memberAccessOperationToExpr mao = + + let obj = Syntax.memberAccessOperationObject mao + member = Syntax.memberAccessOperationMember mao + in (Serialization.noSep [ + postfixExpressionToExpr obj, + (Serialization.cst "."), + (Serialization.cst member)]) + +-- | Convert a member declaration to an expression +memberDeclarationToExpr :: Bool -> Syntax.MemberDeclaration -> Ast.Expr +memberDeclarationToExpr commas m = + case m of + Syntax.MemberDeclarationFunction v0 -> functionDeclarationToExpr v0 + Syntax.MemberDeclarationVariable v0 -> variableDeclarationToExpr commas v0 + Syntax.MemberDeclarationConstructor v0 -> constructorDeclarationToExpr v0 + Syntax.MemberDeclarationDestructor v0 -> destructorDeclarationToExpr v0 + Syntax.MemberDeclarationNestedClass v0 -> classDeclarationToExpr v0 + Syntax.MemberDeclarationTemplate v0 -> templateDeclarationToExpr v0 + +-- | Convert a member specification to an expression +memberSpecificationToExpr :: Bool -> Syntax.MemberSpecification -> Ast.Expr +memberSpecificationToExpr commas m = + case m of + Syntax.MemberSpecificationAccessLabel v0 -> Serialization.noSep [ + accessSpecifierToExpr v0, + (Serialization.cst ":")] + Syntax.MemberSpecificationMember v0 -> memberDeclarationToExpr commas v0 + +-- | Convert a modulo operation to an expression +moduloOperationToExpr :: Syntax.ModuloOperation -> Ast.Expr +moduloOperationToExpr op = + + let left = Syntax.moduloOperationLeft op + right = Syntax.moduloOperationRight op + in (Serialization.spaceSep [ + multiplicativeExpressionToExpr left, + (Serialization.cst "%"), + (unaryExpressionToExpr right)]) + +-- | Convert a multiplicative expression to an expression +multiplicativeExpressionToExpr :: Syntax.MultiplicativeExpression -> Ast.Expr +multiplicativeExpressionToExpr e = + case e of + Syntax.MultiplicativeExpressionUnary v0 -> unaryExpressionToExpr v0 + Syntax.MultiplicativeExpressionMultiply v0 -> multiplyOperationToExpr v0 + Syntax.MultiplicativeExpressionDivide v0 -> divideOperationToExpr v0 + Syntax.MultiplicativeExpressionModulo v0 -> moduloOperationToExpr v0 + +-- | Convert a multiply operation to an expression +multiplyOperationToExpr :: Syntax.MultiplyOperation -> Ast.Expr +multiplyOperationToExpr op = + + let left = Syntax.multiplyOperationLeft op + right = Syntax.multiplyOperationRight op + in (Serialization.spaceSep [ + multiplicativeExpressionToExpr left, + (Serialization.cst "*"), + (unaryExpressionToExpr right)]) + +-- | Convert a namespace declaration to an expression +namespaceDeclarationToExpr :: Syntax.NamespaceDeclaration -> Ast.Expr +namespaceDeclarationToExpr nd = + + let name = Syntax.namespaceDeclarationName nd + decls = Syntax.namespaceDeclarationDeclarations nd + in (Serialization.spaceSep [ + Serialization.cst (Strings.concat2 "namespace " name), + (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map declarationToExpr decls)))]) + +-- | Convert a not-equal operation to an expression +notEqualOperationToExpr :: Syntax.NotEqualOperation -> Ast.Expr +notEqualOperationToExpr op = + + let left = Syntax.notEqualOperationLeft op + right = Syntax.notEqualOperationRight op + in (Serialization.spaceSep [ + equalityExpressionToExpr left, + (Serialization.cst "!="), + (relationalExpressionToExpr right)]) + +-- | Convert an optional to an expression +optionalToExpr :: Syntax.Optional -> Ast.Expr +optionalToExpr opt = + + let valType = Syntax.optionalValueType opt + val = Syntax.optionalValue opt + in (Serialization.spaceSep [ + Serialization.cst "std::optional<", + (typeExpressionToExpr valType), + (Serialization.cst ">"), + (Optionals.match val (Serialization.cst "{}") (\v -> Serialization.curlyBracesList Nothing Serialization.inlineStyle [ + expressionToExpr v]))]) + +-- | Convert overloaded lambdas to an expression +overloadedLambdasToExpr :: Syntax.OverloadedLambdas -> Ast.Expr +overloadedLambdasToExpr ol = + Serialization.spaceSep [ + Serialization.cst "overloaded", + (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map lambdaExpressionToExpr (Syntax.unOverloadedLambdas ol))))] + +-- | Convert a parameter to an expression +parameterToExpr :: Syntax.Parameter -> Ast.Expr +parameterToExpr p = + + let typ = Syntax.parameterType p + name = Syntax.parameterName p + unnamed = Syntax.parameterUnnamed p + defaultVal = Syntax.parameterDefaultValue p + nameExpr = + Serialization.cst (Logic.ifElse unnamed (Strings.concat [ + "/*", + name, + "*/"]) name) + in (Serialization.spaceSep (Lists.concat [ + [ + typeExpressionToExpr typ, + nameExpr], + (Optionals.match defaultVal [] (\expr -> [ + Serialization.cst "=", + (expressionToExpr expr)]))])) + +-- | Convert a pattern match to an expression +patternMatchToExpr :: Syntax.PatternMatch -> Ast.Expr +patternMatchToExpr pm = + + let visitor = Syntax.patternMatchVisitor pm + variant = Syntax.patternMatchVariant pm + in (Serialization.spaceSep [ + Serialization.cst "std::visit", + (Serialization.parenListAdaptive [ + visitorToExpr visitor, + (expressionToExpr variant)])]) + +-- | Convert a pointer member access operation to an expression +pointerMemberAccessOperationToExpr :: Syntax.PointerMemberAccessOperation -> Ast.Expr +pointerMemberAccessOperationToExpr pmao = + + let ptr = Syntax.pointerMemberAccessOperationPointer pmao + member = Syntax.pointerMemberAccessOperationMember pmao + in (Serialization.noSep [ + postfixExpressionToExpr ptr, + (Serialization.cst "->"), + (Serialization.cst member)]) + +-- | Convert a postfix expression to an expression +postfixExpressionToExpr :: Syntax.PostfixExpression -> Ast.Expr +postfixExpressionToExpr e = + case e of + Syntax.PostfixExpressionPrimary v0 -> primaryExpressionToExpr v0 + Syntax.PostfixExpressionSubscript v0 -> subscriptOperationToExpr v0 + Syntax.PostfixExpressionFunctionCall v0 -> functionCallOperationToExpr v0 + Syntax.PostfixExpressionTemplateFunctionCall v0 -> templateFunctionCallOperationToExpr v0 + Syntax.PostfixExpressionMemberAccess v0 -> memberAccessOperationToExpr v0 + Syntax.PostfixExpressionPointerMemberAccess v0 -> pointerMemberAccessOperationToExpr v0 + Syntax.PostfixExpressionPostIncrement v0 -> Serialization.noSep [ + postfixExpressionToExpr v0, + (Serialization.cst "++")] + Syntax.PostfixExpressionPostDecrement v0 -> Serialization.noSep [ + postfixExpressionToExpr v0, + (Serialization.cst "--")] + +-- | Convert a pragma directive to an expression +pragmaDirectiveToExpr :: Syntax.PragmaDirective -> Ast.Expr +pragmaDirectiveToExpr pd = Serialization.cst (Strings.concat2 "#pragma " (Syntax.pragmaDirectiveContent pd)) + +-- | Convert a preprocessor directive to an expression +preprocessorDirectiveToExpr :: Syntax.PreprocessorDirective -> Ast.Expr +preprocessorDirectiveToExpr d = + case d of + Syntax.PreprocessorDirectiveInclude v0 -> includeDirectiveToExpr v0 + Syntax.PreprocessorDirectivePragma v0 -> pragmaDirectiveToExpr v0 + Syntax.PreprocessorDirectiveDefine v0 -> defineDirectiveToExpr v0 + Syntax.PreprocessorDirectiveUndef v0 -> undefDirectiveToExpr v0 + Syntax.PreprocessorDirectiveIfdef v0 -> ifdefDirectiveToExpr v0 + Syntax.PreprocessorDirectiveIfndef v0 -> ifndefDirectiveToExpr v0 + Syntax.PreprocessorDirectiveIf v0 -> ifDirectiveToExpr v0 + Syntax.PreprocessorDirectiveElif v0 -> elifDirectiveToExpr v0 + Syntax.PreprocessorDirectiveElse v0 -> elseDirectiveToExpr v0 + Syntax.PreprocessorDirectiveEndif v0 -> endifDirectiveToExpr v0 + Syntax.PreprocessorDirectiveLine v0 -> lineDirectiveToExpr v0 + Syntax.PreprocessorDirectiveError v0 -> errorDirectiveToExpr v0 + Syntax.PreprocessorDirectiveWarning v0 -> warningDirectiveToExpr v0 + +-- | Convert a primary expression to an expression +primaryExpressionToExpr :: Syntax.PrimaryExpression -> Ast.Expr +primaryExpressionToExpr e = + case e of + Syntax.PrimaryExpressionIdentifier v0 -> Serialization.cst v0 + Syntax.PrimaryExpressionLiteral v0 -> literalToExpr v0 + Syntax.PrimaryExpressionParenthesized v0 -> Serialization.parens (expressionToExpr v0) + Syntax.PrimaryExpressionLambda v0 -> lambdaExpressionToExpr v0 + +-- | Convert a program to an expression +programToExpr :: Syntax.Program -> Ast.Expr +programToExpr prog = + + let preps = Syntax.programPreprocessorDirectives prog + includes = Syntax.programIncludes prog + decls = Syntax.programDeclarations prog + separate = \sep -> \defs -> Logic.ifElse (Lists.isEmpty defs) Nothing (Just (sep defs)) + in (Serialization.doubleNewlineSep (Optionals.givens [ + separate Serialization.newlineSep (Lists.map preprocessorDirectiveToExpr preps), + (separate Serialization.newlineSep (Lists.map includeDirectiveToExpr includes)), + (separate Serialization.doubleNewlineSep (Lists.map declarationToExpr decls))])) + +-- | Convert a qualified identifier to an expression +qualifiedIdentifierToExpr :: Syntax.QualifiedIdentifier -> Ast.Expr +qualifiedIdentifierToExpr qi = + + let ns = Syntax.qualifiedIdentifierNamespace qi + name = Syntax.qualifiedIdentifierName qi + in (Serialization.cst (Strings.concat [ + ns, + "::", + name])) + +-- | Convert a qualified type to an expression +qualifiedTypeToExpr :: Syntax.QualifiedType -> Ast.Expr +qualifiedTypeToExpr qt = + + let baseType = Syntax.qualifiedTypeBaseType qt + qualifier = Syntax.qualifiedTypeQualifier qt + in case qualifier of + Syntax.TypeQualifierConst -> Serialization.spaceSep [ + Serialization.cst "const", + (typeExpressionToExpr baseType)] + Syntax.TypeQualifierLvalueRef -> Serialization.noSep [ + typeExpressionToExpr baseType, + (Serialization.cst "&")] + Syntax.TypeQualifierRvalueRef -> Serialization.noSep [ + typeExpressionToExpr baseType, + (Serialization.cst "&&")] + Syntax.TypeQualifierPointer -> Serialization.noSep [ + typeExpressionToExpr baseType, + (Serialization.cst "*")] + +-- | Convert a range-for statement to an expression +rangeForStatementToExpr :: Syntax.RangeForStatement -> Ast.Expr +rangeForStatementToExpr rfs = + + let typ = Syntax.rangeForStatementType rfs + var = Syntax.rangeForStatementVariable rfs + range = Syntax.rangeForStatementRange rfs + body = Syntax.rangeForStatementBody rfs + in (Serialization.newlineSep [ + Serialization.spaceSep [ + Serialization.cst "for", + (Serialization.parens (Serialization.spaceSep [ + typeExpressionToExpr typ, + (Serialization.cst var), + (Serialization.cst ":"), + (expressionToExpr range)]))], + (statementToExpr body)]) + +-- | Convert a relational expression to an expression +relationalExpressionToExpr :: Syntax.RelationalExpression -> Ast.Expr +relationalExpressionToExpr e = + case e of + Syntax.RelationalExpressionShift v0 -> shiftExpressionToExpr v0 + Syntax.RelationalExpressionLess v0 -> lessOperationToExpr v0 + Syntax.RelationalExpressionGreater v0 -> greaterOperationToExpr v0 + Syntax.RelationalExpressionLessEqual v0 -> lessEqualOperationToExpr v0 + Syntax.RelationalExpressionGreaterEqual v0 -> greaterEqualOperationToExpr v0 + +-- | Convert a right shift operation to an expression +rightShiftOperationToExpr :: Syntax.RightShiftOperation -> Ast.Expr +rightShiftOperationToExpr op = + + let left = Syntax.rightShiftOperationLeft op + right = Syntax.rightShiftOperationRight op + in (Serialization.spaceSep [ + shiftExpressionToExpr left, + (Serialization.cst ">>"), + (additiveExpressionToExpr right)]) + +-- | Convert a selection statement to an expression +selectionStatementToExpr :: Syntax.SelectionStatement -> Ast.Expr +selectionStatementToExpr ss = + + let cond = Syntax.selectionStatementCondition ss + thenBranch = Syntax.selectionStatementThenBranch ss + elseBranch = Syntax.selectionStatementElseBranch ss + in (Serialization.newlineSep [ + Serialization.spaceSep [ + Serialization.cst "if", + (Serialization.parens (expressionToExpr cond))], + (statementToExpr thenBranch), + (Optionals.match elseBranch (Serialization.cst "") (\stmt -> Serialization.newlineSep [ + Serialization.cst "else", + (statementToExpr stmt)]))]) + +-- | Convert a set to an expression +setToExpr :: Syntax.Set -> Ast.Expr +setToExpr s = + + let elemType = Syntax.setElementType s + elems = Syntax.setElements s + in (Serialization.spaceSep [ + Serialization.cst "std::set<", + (typeExpressionToExpr elemType), + (Serialization.cst ">"), + (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map expressionToExpr elems))]) + +-- | Convert a shift expression to an expression +shiftExpressionToExpr :: Syntax.ShiftExpression -> Ast.Expr +shiftExpressionToExpr e = + case e of + Syntax.ShiftExpressionAdditive v0 -> additiveExpressionToExpr v0 + Syntax.ShiftExpressionLeftShift v0 -> leftShiftOperationToExpr v0 + Syntax.ShiftExpressionRightShift v0 -> rightShiftOperationToExpr v0 + +-- | Convert a sizeof expression to an expression +sizeofExpressionToExpr :: Syntax.SizeofExpression -> Ast.Expr +sizeofExpressionToExpr se = + Serialization.spaceSep [ + Serialization.cst "sizeof", + (Serialization.parens (typeExpressionToExpr (Syntax.unSizeofExpression se)))] + +-- | Convert a statement to an expression +statementToExpr :: Syntax.Statement -> Ast.Expr +statementToExpr s = + case s of + Syntax.StatementLabeled v0 -> labeledStatementToExpr v0 + Syntax.StatementCompound v0 -> compoundStatementToExpr v0 + Syntax.StatementSelection v0 -> selectionStatementToExpr v0 + Syntax.StatementSwitch v0 -> switchStatementToExpr v0 + Syntax.StatementIteration v0 -> iterationStatementToExpr v0 + Syntax.StatementJump v0 -> jumpStatementToExpr v0 + Syntax.StatementDeclaration v0 -> Serialization.withSemi (variableDeclarationToExpr False v0) + Syntax.StatementExpression v0 -> Serialization.withSemi (expressionToExpr v0) + +-- | Convert a subscript operation to an expression +subscriptOperationToExpr :: Syntax.SubscriptOperation -> Ast.Expr +subscriptOperationToExpr so = + + let array = Syntax.subscriptOperationArray so + index = Syntax.subscriptOperationIndex so + in (Serialization.noSep [ + postfixExpressionToExpr array, + (Serialization.cst "["), + (expressionToExpr index), + (Serialization.cst "]")]) + +-- | Convert a subtract operation to an expression +subtractOperationToExpr :: Syntax.SubtractOperation -> Ast.Expr +subtractOperationToExpr op = + + let left = Syntax.subtractOperationLeft op + right = Syntax.subtractOperationRight op + in (Serialization.spaceSep [ + additiveExpressionToExpr left, + (Serialization.cst "-"), + (multiplicativeExpressionToExpr right)]) + +-- | Convert a switch statement to an expression +switchStatementToExpr :: Syntax.SwitchStatement -> Ast.Expr +switchStatementToExpr ss = + + let value = Syntax.switchStatementValue ss + match = Syntax.switchStatementCases ss + in (Serialization.spaceSep [ + Serialization.cst "switch", + (Serialization.parens (expressionToExpr value)), + (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map caseStatementToExpr match)))]) + +-- | Convert a template argument to an expression +templateArgumentToExpr :: Syntax.TemplateArgument -> Ast.Expr +templateArgumentToExpr a = + case a of + Syntax.TemplateArgumentType v0 -> typeExpressionToExpr v0 + Syntax.TemplateArgumentValue v0 -> expressionToExpr v0 + +-- | Convert a template declaration to an expression +templateDeclarationToExpr :: Syntax.TemplateDeclaration -> Ast.Expr +templateDeclarationToExpr td = + + let inline = Syntax.templateDeclarationInline td + params = Syntax.templateDeclarationParameters td + declaration = Syntax.templateDeclarationDeclaration td + sep = Logic.ifElse inline Serialization.spaceSep Serialization.newlineSep + in (sep [ + Serialization.noSep [ + Serialization.cst "template", + (Serialization.angleBracesList Serialization.inlineStyle (Lists.map (\p -> Serialization.cst p) params))], + (declarationToExpr declaration)]) + +-- | Convert a template function call operation to an expression +templateFunctionCallOperationToExpr :: Syntax.TemplateFunctionCallOperation -> Ast.Expr +templateFunctionCallOperationToExpr tfco = + + let func = Syntax.templateFunctionCallOperationFunction tfco + templateArgs = Syntax.templateFunctionCallOperationTemplateArguments tfco + args = Syntax.templateFunctionCallOperationArguments tfco + in (Serialization.noSep [ + postfixExpressionToExpr func, + (Serialization.angleBracesList Serialization.inlineStyle (Lists.map templateArgumentToExpr templateArgs)), + (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) + +-- | Convert a template type to an expression +templateTypeToExpr :: Syntax.TemplateType -> Ast.Expr +templateTypeToExpr tt = + + let name = Syntax.templateTypeName tt + args = Syntax.templateTypeArguments tt + in (Serialization.noSep [ + Serialization.cst name, + (Serialization.angleBracesList Serialization.inlineStyle (Lists.map templateArgumentToExpr args))]) + +-- | Convert a ternary expression to an expression +ternaryExpressionToExpr :: Syntax.TernaryExpression -> Ast.Expr +ternaryExpressionToExpr te = + + let cond = Syntax.ternaryExpressionCondition te + trueExpr = Syntax.ternaryExpressionTrueExpr te + falseExpr = Syntax.ternaryExpressionFalseExpr te + in (Serialization.spaceSep [ + logicalOrExpressionToExpr cond, + (Serialization.cst "?"), + (expressionToExpr trueExpr), + (Serialization.cst ":"), + (conditionalExpressionToExpr falseExpr)]) + +-- | Convert a string to a C++ comment. Empty single-line comments emit `//` (no trailing space). +toCppComments :: String -> Bool -> String +toCppComments s isMultiline = + Logic.ifElse isMultiline (Strings.concat [ + "/* ", + s, + " */"]) (Logic.ifElse (Equality.equal s "") "//" (Strings.concat2 "// " s)) + +-- | Convert a type expression to an expression +typeExpressionToExpr :: Syntax.TypeExpression -> Ast.Expr +typeExpressionToExpr t = + case t of + Syntax.TypeExpressionBasic v0 -> basicTypeToExpr v0 + Syntax.TypeExpressionQualified v0 -> qualifiedTypeToExpr v0 + Syntax.TypeExpressionTemplate v0 -> templateTypeToExpr v0 + Syntax.TypeExpressionFunction v0 -> functionTypeToExpr v0 + Syntax.TypeExpressionAuto -> Serialization.cst "auto" + +-- | Convert a typedef declaration to an expression +typedefDeclarationToExpr :: Syntax.TypedefDeclaration -> Ast.Expr +typedefDeclarationToExpr td = + + let name = Syntax.typedefDeclarationName td + typ = Syntax.typedefDeclarationType td + isUsing = Syntax.typedefDeclarationIsUsing td + in (Logic.ifElse isUsing (Serialization.withSemi (Serialization.spaceSep [ + Serialization.cst (Strings.concat2 "using " name), + (Serialization.cst "="), + (typeExpressionToExpr typ)])) (Serialization.withSemi (Serialization.spaceSep [ + Serialization.cst "typedef", + (typeExpressionToExpr typ), + (Serialization.cst name)]))) + +-- | Convert a unary expression to an expression +unaryExpressionToExpr :: Syntax.UnaryExpression -> Ast.Expr +unaryExpressionToExpr e = + case e of + Syntax.UnaryExpressionPostfix v0 -> postfixExpressionToExpr v0 + Syntax.UnaryExpressionUnaryOp v0 -> unaryOperationToExpr v0 + Syntax.UnaryExpressionSizeof v0 -> sizeofExpressionToExpr v0 + +-- | Convert a unary operation to an expression +unaryOperationToExpr :: Syntax.UnaryOperation -> Ast.Expr +unaryOperationToExpr uo = + + let op = Syntax.unaryOperationOperator uo + operand = Syntax.unaryOperationOperand uo + in (Serialization.spaceSep [ + unaryOperatorToExpr op, + (unaryExpressionToExpr operand)]) + +-- | Convert a unary operator to an expression +unaryOperatorToExpr :: Syntax.UnaryOperator -> Ast.Expr +unaryOperatorToExpr op = + case op of + Syntax.UnaryOperatorPlus -> Serialization.cst "+" + Syntax.UnaryOperatorMinus -> Serialization.cst "-" + Syntax.UnaryOperatorLogicalNot -> Serialization.cst "!" + Syntax.UnaryOperatorBitwiseNot -> Serialization.cst "~" + Syntax.UnaryOperatorDereference -> Serialization.cst "*" + Syntax.UnaryOperatorAddressOf -> Serialization.cst "&" + Syntax.UnaryOperatorPreIncrement -> Serialization.cst "++" + Syntax.UnaryOperatorPreDecrement -> Serialization.cst "--" + +-- | Convert an undef directive to an expression +undefDirectiveToExpr :: Syntax.UndefDirective -> Ast.Expr +undefDirectiveToExpr ud = + Serialization.spaceSep [ + Serialization.cst "#undef", + (Serialization.cst (Syntax.undefDirectiveName ud))] + +-- | Convert a variable declaration to an expression +variableDeclarationToExpr :: Bool -> Syntax.VariableDeclaration -> Ast.Expr +variableDeclarationToExpr commas vd = + + let typ = Syntax.variableDeclarationType vd + name = Syntax.variableDeclarationName vd + init = Syntax.variableDeclarationInitializer vd + isAuto = Syntax.variableDeclarationIsAuto vd + terminator = Logic.ifElse commas Serialization.withComma Serialization.withSemi + in (terminator (Serialization.spaceSep (Lists.concat [ + Logic.ifElse isAuto [ + Serialization.cst "auto"] (Optionals.match typ [] (\t -> [ + typeExpressionToExpr t])), + [ + Serialization.cst name], + (Optionals.match init [] (\expr -> [ + Serialization.cst "=", + (expressionToExpr expr)]))]))) + +-- | Convert a vector to an expression +vectorToExpr :: Syntax.Vector -> Ast.Expr +vectorToExpr v = + + let elemType = Syntax.vectorElementType v + elems = Syntax.vectorElements v + in (Serialization.spaceSep [ + Serialization.cst "std::vector<", + (typeExpressionToExpr elemType), + (Serialization.cst ">"), + (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map expressionToExpr elems))]) + +-- | Convert a visitor to an expression +visitorToExpr :: Syntax.Visitor -> Ast.Expr +visitorToExpr v = + case v of + Syntax.VisitorLambda v0 -> lambdaExpressionToExpr v0 + Syntax.VisitorOverloaded v0 -> overloadedLambdasToExpr v0 + +-- | Convert a warning directive to an expression +warningDirectiveToExpr :: Syntax.WarningDirective -> Ast.Expr +warningDirectiveToExpr wd = + Serialization.spaceSep [ + Serialization.cst "#warning", + (Serialization.cst (Syntax.warningDirectiveMessage wd))] + +-- | Convert a while statement to an expression +whileStatementToExpr :: Syntax.WhileStatement -> Ast.Expr +whileStatementToExpr ws = + + let cond = Syntax.whileStatementCondition ws + body = Syntax.whileStatementBody ws + in (Serialization.newlineSep [ + Serialization.spaceSep [ + Serialization.cst "while", + (Serialization.parens (expressionToExpr cond))], + (statementToExpr body)]) diff --git a/src/main/haskell/Hydra/Ext/Cpp/Syntax.hs b/src/main/haskell/Hydra/Ext/Cpp/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Syntax.hs @@ -0,0 +1,2033 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A C++ syntax model, focusing on features for representing algebraic data types and declarative computations + +module Hydra.Ext.Cpp.Syntax where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A C++ member or base-class access specifier: public, protected, or private +data AccessSpecifier = + AccessSpecifierPublic | + AccessSpecifierProtected | + AccessSpecifierPrivate | + AccessSpecifierNone + deriving (Eq, Ord, Read, Show) + +_AccessSpecifier = Model.Name "hydra.ext.cpp.syntax.AccessSpecifier" + +_AccessSpecifier_public = Model.Name "public" + +_AccessSpecifier_protected = Model.Name "protected" + +_AccessSpecifier_private = Model.Name "private" + +_AccessSpecifier_none = Model.Name "none" + +-- | A C++ binary addition expression (left + right) +data AddOperation = + AddOperation { + addOperationLeft :: AdditiveExpression, + addOperationRight :: MultiplicativeExpression} + deriving (Eq, Ord, Read, Show) + +_AddOperation = Model.Name "hydra.ext.cpp.syntax.AddOperation" + +_AddOperation_left = Model.Name "left" + +_AddOperation_right = Model.Name "right" + +-- | A C++ additive-expression: a multiplicative expression, an addition, or a subtraction +data AdditiveExpression = + AdditiveExpressionMultiplicative MultiplicativeExpression | + AdditiveExpressionAdd AddOperation | + AdditiveExpressionSubtract SubtractOperation + deriving (Eq, Ord, Read, Show) + +_AdditiveExpression = Model.Name "hydra.ext.cpp.syntax.AdditiveExpression" + +_AdditiveExpression_multiplicative = Model.Name "multiplicative" + +_AdditiveExpression_add = Model.Name "add" + +_AdditiveExpression_subtract = Model.Name "subtract" + +-- | A C++ and-expression: an equality expression or a bitwise AND operation +data AndExpression = + AndExpressionEquality EqualityExpression | + AndExpressionBitwiseAnd BitwiseAndOperation + deriving (Eq, Ord, Read, Show) + +_AndExpression = Model.Name "hydra.ext.cpp.syntax.AndExpression" + +_AndExpression_equality = Model.Name "equality" + +_AndExpression_bitwiseAnd = Model.Name "bitwiseAnd" + +-- | A C++ assignment-expression: a conditional expression or an explicit assignment +data AssignmentExpression = + AssignmentExpressionConditional ConditionalExpression | + AssignmentExpressionAssignment ExplicitAssignment + deriving (Eq, Ord, Read, Show) + +_AssignmentExpression = Model.Name "hydra.ext.cpp.syntax.AssignmentExpression" + +_AssignmentExpression_conditional = Model.Name "conditional" + +_AssignmentExpression_assignment = Model.Name "assignment" + +-- | A C++ assignment operator, such as =, +=, or <<= +data AssignmentOperator = + AssignmentOperatorAssign | + AssignmentOperatorPlusAssign | + AssignmentOperatorMinusAssign | + AssignmentOperatorMultiplyAssign | + AssignmentOperatorDivideAssign | + AssignmentOperatorModuloAssign | + AssignmentOperatorLeftShiftAssign | + AssignmentOperatorRightShiftAssign | + AssignmentOperatorBitwiseAndAssign | + AssignmentOperatorBitwiseXorAssign | + AssignmentOperatorBitwiseOrAssign + deriving (Eq, Ord, Read, Show) + +_AssignmentOperator = Model.Name "hydra.ext.cpp.syntax.AssignmentOperator" + +_AssignmentOperator_assign = Model.Name "assign" + +_AssignmentOperator_plusAssign = Model.Name "plusAssign" + +_AssignmentOperator_minusAssign = Model.Name "minusAssign" + +_AssignmentOperator_multiplyAssign = Model.Name "multiplyAssign" + +_AssignmentOperator_divideAssign = Model.Name "divideAssign" + +_AssignmentOperator_moduloAssign = Model.Name "moduloAssign" + +_AssignmentOperator_leftShiftAssign = Model.Name "leftShiftAssign" + +_AssignmentOperator_rightShiftAssign = Model.Name "rightShiftAssign" + +_AssignmentOperator_bitwiseAndAssign = Model.Name "bitwiseAndAssign" + +_AssignmentOperator_bitwiseXorAssign = Model.Name "bitwiseXorAssign" + +_AssignmentOperator_bitwiseOrAssign = Model.Name "bitwiseOrAssign" + +-- | A C++ base class specifier within a class's inheritance list +data BaseSpecifier = + BaseSpecifier { + baseSpecifierAccess :: AccessSpecifier, + baseSpecifierName :: String} + deriving (Eq, Ord, Read, Show) + +_BaseSpecifier = Model.Name "hydra.ext.cpp.syntax.BaseSpecifier" + +_BaseSpecifier_access = Model.Name "access" + +_BaseSpecifier_name = Model.Name "name" + +-- | A C++ built-in or named basic type +data BasicType = + BasicTypeVoid | + BasicTypeBool | + BasicTypeChar | + BasicTypeInt | + BasicTypeFloat | + BasicTypeDouble | + BasicTypeString | + BasicTypeAuto | + BasicTypeNamed String + deriving (Eq, Ord, Read, Show) + +_BasicType = Model.Name "hydra.ext.cpp.syntax.BasicType" + +_BasicType_void = Model.Name "void" + +_BasicType_bool = Model.Name "bool" + +_BasicType_char = Model.Name "char" + +_BasicType_int = Model.Name "int" + +_BasicType_float = Model.Name "float" + +_BasicType_double = Model.Name "double" + +_BasicType_string = Model.Name "string" + +_BasicType_auto = Model.Name "auto" + +_BasicType_named = Model.Name "named" + +-- | A C++ binary operator +data BinaryOperator = + BinaryOperatorPlus | + BinaryOperatorMinus | + BinaryOperatorMultiply | + BinaryOperatorDivide | + BinaryOperatorModulo | + BinaryOperatorBitwiseAnd | + BinaryOperatorBitwiseOr | + BinaryOperatorBitwiseXor | + BinaryOperatorLogicalAnd | + BinaryOperatorLogicalOr | + BinaryOperatorEqual | + BinaryOperatorNotEqual | + BinaryOperatorLess | + BinaryOperatorGreater | + BinaryOperatorLessEqual | + BinaryOperatorGreaterEqual | + BinaryOperatorLeftShift | + BinaryOperatorRightShift + deriving (Eq, Ord, Read, Show) + +_BinaryOperator = Model.Name "hydra.ext.cpp.syntax.BinaryOperator" + +_BinaryOperator_plus = Model.Name "plus" + +_BinaryOperator_minus = Model.Name "minus" + +_BinaryOperator_multiply = Model.Name "multiply" + +_BinaryOperator_divide = Model.Name "divide" + +_BinaryOperator_modulo = Model.Name "modulo" + +_BinaryOperator_bitwiseAnd = Model.Name "bitwiseAnd" + +_BinaryOperator_bitwiseOr = Model.Name "bitwiseOr" + +_BinaryOperator_bitwiseXor = Model.Name "bitwiseXor" + +_BinaryOperator_logicalAnd = Model.Name "logicalAnd" + +_BinaryOperator_logicalOr = Model.Name "logicalOr" + +_BinaryOperator_equal = Model.Name "equal" + +_BinaryOperator_notEqual = Model.Name "notEqual" + +_BinaryOperator_less = Model.Name "less" + +_BinaryOperator_greater = Model.Name "greater" + +_BinaryOperator_lessEqual = Model.Name "lessEqual" + +_BinaryOperator_greaterEqual = Model.Name "greaterEqual" + +_BinaryOperator_leftShift = Model.Name "leftShift" + +_BinaryOperator_rightShift = Model.Name "rightShift" + +-- | A C++ bitwise AND expression (left & right) +data BitwiseAndOperation = + BitwiseAndOperation { + bitwiseAndOperationLeft :: AndExpression, + bitwiseAndOperationRight :: EqualityExpression} + deriving (Eq, Ord, Read, Show) + +_BitwiseAndOperation = Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation" + +_BitwiseAndOperation_left = Model.Name "left" + +_BitwiseAndOperation_right = Model.Name "right" + +-- | A C++ bitwise OR expression (left | right) +data BitwiseOrOperation = + BitwiseOrOperation { + bitwiseOrOperationLeft :: InclusiveOrExpression, + bitwiseOrOperationRight :: ExclusiveOrExpression} + deriving (Eq, Ord, Read, Show) + +_BitwiseOrOperation = Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation" + +_BitwiseOrOperation_left = Model.Name "left" + +_BitwiseOrOperation_right = Model.Name "right" + +-- | A C++ bitwise XOR expression (left ^ right) +data BitwiseXorOperation = + BitwiseXorOperation { + bitwiseXorOperationLeft :: ExclusiveOrExpression, + bitwiseXorOperationRight :: AndExpression} + deriving (Eq, Ord, Read, Show) + +_BitwiseXorOperation = Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation" + +_BitwiseXorOperation_left = Model.Name "left" + +_BitwiseXorOperation_right = Model.Name "right" + +-- | A C++ boolean literal (true or false) +newtype BooleanLiteral = + BooleanLiteral { + unBooleanLiteral :: Bool} + deriving (Eq, Ord, Read, Show) + +_BooleanLiteral = Model.Name "hydra.ext.cpp.syntax.BooleanLiteral" + +-- | A single variable captured by a C++ lambda expression +data Capture = + Capture { + captureName :: String, + captureByReference :: Bool} + deriving (Eq, Ord, Read, Show) + +_Capture = Model.Name "hydra.ext.cpp.syntax.Capture" + +_Capture_name = Model.Name "name" + +_Capture_byReference = Model.Name "byReference" + +-- | A C++ lambda capture list: capture-by-value ([=]) or an explicit list of captures +data CaptureList = + CaptureListCaptureByValue | + CaptureListCaptures [Capture] + deriving (Eq, Ord, Read, Show) + +_CaptureList = Model.Name "hydra.ext.cpp.syntax.CaptureList" + +_CaptureList_captureByValue = Model.Name "captureByValue" + +_CaptureList_captures = Model.Name "captures" + +-- | A single case or default branch of a C++ switch statement +data CaseStatement = + CaseStatementCase CaseValue | + CaseStatementDefault Statement + deriving (Eq, Ord, Read, Show) + +_CaseStatement = Model.Name "hydra.ext.cpp.syntax.CaseStatement" + +_CaseStatement_case = Model.Name "case" + +_CaseStatement_default = Model.Name "default" + +-- | A C++ switch case label together with its associated statement +data CaseValue = + CaseValue { + caseValueValue :: Expression, + caseValueStatement :: Statement} + deriving (Eq, Ord, Read, Show) + +_CaseValue = Model.Name "hydra.ext.cpp.syntax.CaseValue" + +_CaseValue_value = Model.Name "value" + +_CaseValue_statement = Model.Name "statement" + +-- | A C++ character literal +newtype CharacterLiteral = + CharacterLiteral { + unCharacterLiteral :: String} + deriving (Eq, Ord, Read, Show) + +_CharacterLiteral = Model.Name "hydra.ext.cpp.syntax.CharacterLiteral" + +-- | The body of a C++ class, struct, or enum declaration: a list of member specifications +newtype ClassBody = + ClassBody { + unClassBody :: [MemberSpecification]} + deriving (Eq, Ord, Read, Show) + +_ClassBody = Model.Name "hydra.ext.cpp.syntax.ClassBody" + +-- | A C++ class, struct, or enum declaration, with an optional body +data ClassDeclaration = + ClassDeclaration { + classDeclarationSpecifier :: ClassSpecifier, + classDeclarationBody :: (Maybe ClassBody)} + deriving (Eq, Ord, Read, Show) + +_ClassDeclaration = Model.Name "hydra.ext.cpp.syntax.ClassDeclaration" + +_ClassDeclaration_specifier = Model.Name "specifier" + +_ClassDeclaration_body = Model.Name "body" + +-- | The keyword introducing a C++ class-like declaration: class, enum, enum class, or struct +data ClassKey = + ClassKeyClass | + ClassKeyEnum | + ClassKeyEnumClass | + ClassKeyStruct + deriving (Eq, Ord, Read, Show) + +_ClassKey = Model.Name "hydra.ext.cpp.syntax.ClassKey" + +_ClassKey_class = Model.Name "class" + +_ClassKey_enum = Model.Name "enum" + +_ClassKey_enumClass = Model.Name "enumClass" + +_ClassKey_struct = Model.Name "struct" + +-- | The head of a C++ class declaration: its key, name, and base class list +data ClassSpecifier = + ClassSpecifier { + classSpecifierKey :: ClassKey, + classSpecifierName :: String, + classSpecifierInheritance :: [BaseSpecifier]} + deriving (Eq, Ord, Read, Show) + +_ClassSpecifier = Model.Name "hydra.ext.cpp.syntax.ClassSpecifier" + +_ClassSpecifier_key = Model.Name "key" + +_ClassSpecifier_name = Model.Name "name" + +_ClassSpecifier_inheritance = Model.Name "inheritance" + +-- | A C++ comma expression (left, right) +data CommaExpression = + CommaExpression { + commaExpressionLeft :: Expression, + commaExpressionRight :: AssignmentExpression} + deriving (Eq, Ord, Read, Show) + +_CommaExpression = Model.Name "hydra.ext.cpp.syntax.CommaExpression" + +_CommaExpression_left = Model.Name "left" + +_CommaExpression_right = Model.Name "right" + +-- | A C++ line or block comment +data Comment = + Comment { + commentText :: String, + commentIsMultiline :: Bool} + deriving (Eq, Ord, Read, Show) + +_Comment = Model.Name "hydra.ext.cpp.syntax.Comment" + +_Comment_text = Model.Name "text" + +_Comment_isMultiline = Model.Name "isMultiline" + +-- | A C++ compound statement: a brace-enclosed block of statements +newtype CompoundStatement = + CompoundStatement { + unCompoundStatement :: [Statement]} + deriving (Eq, Ord, Read, Show) + +_CompoundStatement = Model.Name "hydra.ext.cpp.syntax.CompoundStatement" + +-- | A C++ conditional-expression: a logical-or expression or a ternary expression +data ConditionalExpression = + ConditionalExpressionLogicalOr LogicalOrExpression | + ConditionalExpressionTernary TernaryExpression + deriving (Eq, Ord, Read, Show) + +_ConditionalExpression = Model.Name "hydra.ext.cpp.syntax.ConditionalExpression" + +_ConditionalExpression_logicalOr = Model.Name "logicalOr" + +_ConditionalExpression_ternary = Model.Name "ternary" + +-- | A C++ constructor declaration, with parameters, member initializers, and a body +data ConstructorDeclaration = + ConstructorDeclaration { + constructorDeclarationName :: String, + constructorDeclarationParameters :: [Parameter], + constructorDeclarationInitializers :: [MemInitializer], + constructorDeclarationBody :: FunctionBody} + deriving (Eq, Ord, Read, Show) + +_ConstructorDeclaration = Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration" + +_ConstructorDeclaration_name = Model.Name "name" + +_ConstructorDeclaration_parameters = Model.Name "parameters" + +_ConstructorDeclaration_initializers = Model.Name "initializers" + +_ConstructorDeclaration_body = Model.Name "body" + +-- | A declaration of a standard-library container type alias: list, map, set, or optional +data ContainerDeclaration = + ContainerDeclarationList ListDeclaration | + ContainerDeclarationMap MapDeclaration | + ContainerDeclarationSet SetDeclaration | + ContainerDeclarationOptional OptionalDeclaration + deriving (Eq, Ord, Read, Show) + +_ContainerDeclaration = Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration" + +_ContainerDeclaration_list = Model.Name "list" + +_ContainerDeclaration_map = Model.Name "map" + +_ContainerDeclaration_set = Model.Name "set" + +_ContainerDeclaration_optional = Model.Name "optional" + +-- | A top-level C++ declaration +data Declaration = + DeclarationPreprocessor PreprocessorDirective | + DeclarationClass ClassDeclaration | + DeclarationFunction FunctionDeclaration | + DeclarationVariable VariableDeclaration | + DeclarationTypedef TypedefDeclaration | + DeclarationNamespace NamespaceDeclaration | + DeclarationTemplate TemplateDeclaration + deriving (Eq, Ord, Read, Show) + +_Declaration = Model.Name "hydra.ext.cpp.syntax.Declaration" + +_Declaration_preprocessor = Model.Name "preprocessor" + +_Declaration_class = Model.Name "class" + +_Declaration_function = Model.Name "function" + +_Declaration_variable = Model.Name "variable" + +_Declaration_typedef = Model.Name "typedef" + +_Declaration_namespace = Model.Name "namespace" + +_Declaration_template = Model.Name "template" + +-- | A C preprocessor #define directive, optionally function-like +data DefineDirective = + DefineDirective { + defineDirectiveName :: String, + defineDirectiveParameters :: (Maybe [String]), + defineDirectiveReplacement :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_DefineDirective = Model.Name "hydra.ext.cpp.syntax.DefineDirective" + +_DefineDirective_name = Model.Name "name" + +_DefineDirective_parameters = Model.Name "parameters" + +_DefineDirective_replacement = Model.Name "replacement" + +-- | A C++ destructor declaration +data DestructorDeclaration = + DestructorDeclaration { + destructorDeclarationPrefixSpecifiers :: [FunctionSpecifierPrefix], + destructorDeclarationName :: String, + destructorDeclarationSuffixSpecifiers :: [FunctionSpecifierSuffix], + destructorDeclarationBody :: FunctionBody} + deriving (Eq, Ord, Read, Show) + +_DestructorDeclaration = Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration" + +_DestructorDeclaration_prefixSpecifiers = Model.Name "prefixSpecifiers" + +_DestructorDeclaration_name = Model.Name "name" + +_DestructorDeclaration_suffixSpecifiers = Model.Name "suffixSpecifiers" + +_DestructorDeclaration_body = Model.Name "body" + +-- | A C++ division expression (left / right) +data DivideOperation = + DivideOperation { + divideOperationLeft :: MultiplicativeExpression, + divideOperationRight :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_DivideOperation = Model.Name "hydra.ext.cpp.syntax.DivideOperation" + +_DivideOperation_left = Model.Name "left" + +_DivideOperation_right = Model.Name "right" + +-- | A C++ do-while statement +data DoStatement = + DoStatement { + doStatementBody :: Statement, + doStatementCondition :: Expression} + deriving (Eq, Ord, Read, Show) + +_DoStatement = Model.Name "hydra.ext.cpp.syntax.DoStatement" + +_DoStatement_body = Model.Name "body" + +_DoStatement_condition = Model.Name "condition" + +-- | A C preprocessor #elif directive +data ElifDirective = + ElifDirective { + elifDirectiveCondition :: String} + deriving (Eq, Ord, Read, Show) + +_ElifDirective = Model.Name "hydra.ext.cpp.syntax.ElifDirective" + +_ElifDirective_condition = Model.Name "condition" + +-- | A C preprocessor #else directive +type ElseDirective = () + +_ElseDirective = Model.Name "hydra.ext.cpp.syntax.ElseDirective" + +-- | A C preprocessor #endif directive +type EndifDirective = () + +_EndifDirective = Model.Name "hydra.ext.cpp.syntax.EndifDirective" + +-- | A C++ equality comparison expression (left == right) +data EqualOperation = + EqualOperation { + equalOperationLeft :: EqualityExpression, + equalOperationRight :: RelationalExpression} + deriving (Eq, Ord, Read, Show) + +_EqualOperation = Model.Name "hydra.ext.cpp.syntax.EqualOperation" + +_EqualOperation_left = Model.Name "left" + +_EqualOperation_right = Model.Name "right" + +-- | A C++ equality-expression: a relational expression, an equality, or an inequality +data EqualityExpression = + EqualityExpressionRelational RelationalExpression | + EqualityExpressionEqual EqualOperation | + EqualityExpressionNotEqual NotEqualOperation + deriving (Eq, Ord, Read, Show) + +_EqualityExpression = Model.Name "hydra.ext.cpp.syntax.EqualityExpression" + +_EqualityExpression_relational = Model.Name "relational" + +_EqualityExpression_equal = Model.Name "equal" + +_EqualityExpression_notEqual = Model.Name "notEqual" + +-- | A C preprocessor #error directive +data ErrorDirective = + ErrorDirective { + errorDirectiveMessage :: String} + deriving (Eq, Ord, Read, Show) + +_ErrorDirective = Model.Name "hydra.ext.cpp.syntax.ErrorDirective" + +_ErrorDirective_message = Model.Name "message" + +-- | A C++ exclusive-or-expression: an and expression or a bitwise XOR operation +data ExclusiveOrExpression = + ExclusiveOrExpressionAnd AndExpression | + ExclusiveOrExpressionBitwiseXor BitwiseXorOperation + deriving (Eq, Ord, Read, Show) + +_ExclusiveOrExpression = Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression" + +_ExclusiveOrExpression_and = Model.Name "and" + +_ExclusiveOrExpression_bitwiseXor = Model.Name "bitwiseXor" + +-- | A C++ assignment expression with an explicit operator (e.g. left += right) +data ExplicitAssignment = + ExplicitAssignment { + explicitAssignmentLeft :: LogicalOrExpression, + explicitAssignmentOp :: AssignmentOperator, + explicitAssignmentRight :: AssignmentExpression} + deriving (Eq, Ord, Read, Show) + +_ExplicitAssignment = Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment" + +_ExplicitAssignment_left = Model.Name "left" + +_ExplicitAssignment_op = Model.Name "op" + +_ExplicitAssignment_right = Model.Name "right" + +-- | A C++ expression: an assignment expression or a comma expression +data Expression = + ExpressionAssignment AssignmentExpression | + ExpressionComma CommaExpression + deriving (Eq, Ord, Read, Show) + +_Expression = Model.Name "hydra.ext.cpp.syntax.Expression" + +_Expression_assignment = Model.Name "assignment" + +_Expression_comma = Model.Name "comma" + +-- | A C++ expression statement: an expression followed by a semicolon +newtype ExpressionStatement = + ExpressionStatement { + unExpressionStatement :: Expression} + deriving (Eq, Ord, Read, Show) + +_ExpressionStatement = Model.Name "hydra.ext.cpp.syntax.ExpressionStatement" + +-- | A C++ floating-point literal +newtype FloatingLiteral = + FloatingLiteral { + unFloatingLiteral :: Double} + deriving (Eq, Ord, Read, Show) + +_FloatingLiteral = Model.Name "hydra.ext.cpp.syntax.FloatingLiteral" + +-- | The initializer clause of a C++ for statement: an expression, a declaration, or empty +data ForInit = + ForInitExpression Expression | + ForInitDeclaration VariableDeclaration | + ForInitEmpty + deriving (Eq, Ord, Read, Show) + +_ForInit = Model.Name "hydra.ext.cpp.syntax.ForInit" + +_ForInit_expression = Model.Name "expression" + +_ForInit_declaration = Model.Name "declaration" + +_ForInit_empty = Model.Name "empty" + +-- | A C++ for statement +data ForStatement = + ForStatement { + forStatementInit :: ForInit, + forStatementCondition :: Expression, + forStatementIncrement :: Expression, + forStatementBody :: Statement} + deriving (Eq, Ord, Read, Show) + +_ForStatement = Model.Name "hydra.ext.cpp.syntax.ForStatement" + +_ForStatement_init = Model.Name "init" + +_ForStatement_condition = Model.Name "condition" + +_ForStatement_increment = Model.Name "increment" + +_ForStatement_body = Model.Name "body" + +-- | A simplified function call: a function identifier applied to a list of arguments +data FunctionApplication = + FunctionApplication { + functionApplicationFunction :: FunctionIdentifier, + functionApplicationArguments :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_FunctionApplication = Model.Name "hydra.ext.cpp.syntax.FunctionApplication" + +_FunctionApplication_function = Model.Name "function" + +_FunctionApplication_arguments = Model.Name "arguments" + +-- | The body of a C++ function: a compound statement, or a declaration-only/pure/default marker +data FunctionBody = + FunctionBodyCompound CompoundStatement | + FunctionBodyDeclaration | + FunctionBodyPure | + FunctionBodyDefault + deriving (Eq, Ord, Read, Show) + +_FunctionBody = Model.Name "hydra.ext.cpp.syntax.FunctionBody" + +_FunctionBody_compound = Model.Name "compound" + +_FunctionBody_declaration = Model.Name "declaration" + +_FunctionBody_pure = Model.Name "pure" + +_FunctionBody_default = Model.Name "default" + +-- | A C++ function call expression: a postfix expression applied to arguments +data FunctionCallOperation = + FunctionCallOperation { + functionCallOperationFunction :: PostfixExpression, + functionCallOperationArguments :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_FunctionCallOperation = Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation" + +_FunctionCallOperation_function = Model.Name "function" + +_FunctionCallOperation_arguments = Model.Name "arguments" + +-- | A C++ function declaration or definition +data FunctionDeclaration = + FunctionDeclaration { + functionDeclarationPrefixSpecifiers :: [FunctionSpecifierPrefix], + functionDeclarationReturnType :: TypeExpression, + functionDeclarationName :: String, + functionDeclarationParameters :: [Parameter], + functionDeclarationSuffixSpecifiers :: [FunctionSpecifierSuffix], + functionDeclarationBody :: FunctionBody} + deriving (Eq, Ord, Read, Show) + +_FunctionDeclaration = Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration" + +_FunctionDeclaration_prefixSpecifiers = Model.Name "prefixSpecifiers" + +_FunctionDeclaration_returnType = Model.Name "returnType" + +_FunctionDeclaration_name = Model.Name "name" + +_FunctionDeclaration_parameters = Model.Name "parameters" + +_FunctionDeclaration_suffixSpecifiers = Model.Name "suffixSpecifiers" + +_FunctionDeclaration_body = Model.Name "body" + +-- | The identifier of a called function: a simple name or a qualified name +data FunctionIdentifier = + FunctionIdentifierSimple String | + FunctionIdentifierQualified QualifiedIdentifier + deriving (Eq, Ord, Read, Show) + +_FunctionIdentifier = Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier" + +_FunctionIdentifier_simple = Model.Name "simple" + +_FunctionIdentifier_qualified = Model.Name "qualified" + +-- | A C++ function specifier that appears before the declaration: inline, virtual, static, or explicit +data FunctionSpecifierPrefix = + FunctionSpecifierPrefixInline | + FunctionSpecifierPrefixVirtual | + FunctionSpecifierPrefixStatic | + FunctionSpecifierPrefixExplicit + deriving (Eq, Ord, Read, Show) + +_FunctionSpecifierPrefix = Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix" + +_FunctionSpecifierPrefix_inline = Model.Name "inline" + +_FunctionSpecifierPrefix_virtual = Model.Name "virtual" + +_FunctionSpecifierPrefix_static = Model.Name "static" + +_FunctionSpecifierPrefix_explicit = Model.Name "explicit" + +-- | A C++ function specifier that appears after the parameter list: const, noexcept, override, or final +data FunctionSpecifierSuffix = + FunctionSpecifierSuffixConst | + FunctionSpecifierSuffixNoexcept | + FunctionSpecifierSuffixOverride | + FunctionSpecifierSuffixFinal + deriving (Eq, Ord, Read, Show) + +_FunctionSpecifierSuffix = Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix" + +_FunctionSpecifierSuffix_const = Model.Name "const" + +_FunctionSpecifierSuffix_noexcept = Model.Name "noexcept" + +_FunctionSpecifierSuffix_override = Model.Name "override" + +_FunctionSpecifierSuffix_final = Model.Name "final" + +-- | A C++ function type: a return type together with parameter types +data FunctionType = + FunctionType { + functionTypeReturnType :: TypeExpression, + functionTypeParameters :: [Parameter]} + deriving (Eq, Ord, Read, Show) + +_FunctionType = Model.Name "hydra.ext.cpp.syntax.FunctionType" + +_FunctionType_returnType = Model.Name "returnType" + +_FunctionType_parameters = Model.Name "parameters" + +-- | A C++ greater-than-or-equal comparison expression (left >= right) +data GreaterEqualOperation = + GreaterEqualOperation { + greaterEqualOperationLeft :: RelationalExpression, + greaterEqualOperationRight :: ShiftExpression} + deriving (Eq, Ord, Read, Show) + +_GreaterEqualOperation = Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation" + +_GreaterEqualOperation_left = Model.Name "left" + +_GreaterEqualOperation_right = Model.Name "right" + +-- | A C++ greater-than comparison expression (left > right) +data GreaterOperation = + GreaterOperation { + greaterOperationLeft :: RelationalExpression, + greaterOperationRight :: ShiftExpression} + deriving (Eq, Ord, Read, Show) + +_GreaterOperation = Model.Name "hydra.ext.cpp.syntax.GreaterOperation" + +_GreaterOperation_left = Model.Name "left" + +_GreaterOperation_right = Model.Name "right" + +-- | A C++ identifier +type Identifier = String + +_Identifier = Model.Name "hydra.ext.cpp.syntax.Identifier" + +-- | A C preprocessor #if directive +data IfDirective = + IfDirective { + ifDirectiveCondition :: String} + deriving (Eq, Ord, Read, Show) + +_IfDirective = Model.Name "hydra.ext.cpp.syntax.IfDirective" + +_IfDirective_condition = Model.Name "condition" + +-- | A C preprocessor #ifdef directive +data IfdefDirective = + IfdefDirective { + ifdefDirectiveIdentifier :: String} + deriving (Eq, Ord, Read, Show) + +_IfdefDirective = Model.Name "hydra.ext.cpp.syntax.IfdefDirective" + +_IfdefDirective_identifier = Model.Name "identifier" + +-- | A C preprocessor #ifndef directive +data IfndefDirective = + IfndefDirective { + ifndefDirectiveIdentifier :: String} + deriving (Eq, Ord, Read, Show) + +_IfndefDirective = Model.Name "hydra.ext.cpp.syntax.IfndefDirective" + +_IfndefDirective_identifier = Model.Name "identifier" + +-- | A C preprocessor #include directive, for a system or local header +data IncludeDirective = + IncludeDirective { + includeDirectiveName :: String, + includeDirectiveIsSystem :: Bool} + deriving (Eq, Ord, Read, Show) + +_IncludeDirective = Model.Name "hydra.ext.cpp.syntax.IncludeDirective" + +_IncludeDirective_name = Model.Name "name" + +_IncludeDirective_isSystem = Model.Name "isSystem" + +-- | A C++ inclusive-or-expression: an exclusive-or expression or a bitwise OR operation +data InclusiveOrExpression = + InclusiveOrExpressionExclusiveOr ExclusiveOrExpression | + InclusiveOrExpressionBitwiseOr BitwiseOrOperation + deriving (Eq, Ord, Read, Show) + +_InclusiveOrExpression = Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression" + +_InclusiveOrExpression_exclusiveOr = Model.Name "exclusiveOr" + +_InclusiveOrExpression_bitwiseOr = Model.Name "bitwiseOr" + +-- | A C++ integer literal, in decimal, hexadecimal, octal, or binary form +data IntegerLiteral = + IntegerLiteralDecimal Integer | + IntegerLiteralHexadecimal String | + IntegerLiteralOctal String | + IntegerLiteralBinary String + deriving (Eq, Ord, Read, Show) + +_IntegerLiteral = Model.Name "hydra.ext.cpp.syntax.IntegerLiteral" + +_IntegerLiteral_decimal = Model.Name "decimal" + +_IntegerLiteral_hexadecimal = Model.Name "hexadecimal" + +_IntegerLiteral_octal = Model.Name "octal" + +_IntegerLiteral_binary = Model.Name "binary" + +-- | A C++ iteration statement: while, do-while, for, or range-based for +data IterationStatement = + IterationStatementWhile WhileStatement | + IterationStatementDo DoStatement | + IterationStatementFor ForStatement | + IterationStatementRangeFor RangeForStatement + deriving (Eq, Ord, Read, Show) + +_IterationStatement = Model.Name "hydra.ext.cpp.syntax.IterationStatement" + +_IterationStatement_while = Model.Name "while" + +_IterationStatement_do = Model.Name "do" + +_IterationStatement_for = Model.Name "for" + +_IterationStatement_rangeFor = Model.Name "rangeFor" + +-- | A C++ jump statement: break, continue, return (with or without a value), or throw +data JumpStatement = + JumpStatementBreak | + JumpStatementContinue | + JumpStatementReturnValue Expression | + JumpStatementReturnVoid | + JumpStatementThrow Expression + deriving (Eq, Ord, Read, Show) + +_JumpStatement = Model.Name "hydra.ext.cpp.syntax.JumpStatement" + +_JumpStatement_break = Model.Name "break" + +_JumpStatement_continue = Model.Name "continue" + +_JumpStatement_returnValue = Model.Name "returnValue" + +_JumpStatement_returnVoid = Model.Name "returnVoid" + +_JumpStatement_throw = Model.Name "throw" + +-- | A C++ labeled statement +data LabeledStatement = + LabeledStatement { + labeledStatementLabel :: String, + labeledStatementStatement :: Statement} + deriving (Eq, Ord, Read, Show) + +_LabeledStatement = Model.Name "hydra.ext.cpp.syntax.LabeledStatement" + +_LabeledStatement_label = Model.Name "label" + +_LabeledStatement_statement = Model.Name "statement" + +-- | A C++ lambda expression +data LambdaExpression = + LambdaExpression { + lambdaExpressionCaptures :: CaptureList, + lambdaExpressionParameters :: [Parameter], + lambdaExpressionReturnType :: (Maybe TypeExpression), + lambdaExpressionBody :: CompoundStatement} + deriving (Eq, Ord, Read, Show) + +_LambdaExpression = Model.Name "hydra.ext.cpp.syntax.LambdaExpression" + +_LambdaExpression_captures = Model.Name "captures" + +_LambdaExpression_parameters = Model.Name "parameters" + +_LambdaExpression_returnType = Model.Name "returnType" + +_LambdaExpression_body = Model.Name "body" + +-- | A C++ left shift expression (left << right) +data LeftShiftOperation = + LeftShiftOperation { + leftShiftOperationLeft :: ShiftExpression, + leftShiftOperationRight :: AdditiveExpression} + deriving (Eq, Ord, Read, Show) + +_LeftShiftOperation = Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation" + +_LeftShiftOperation_left = Model.Name "left" + +_LeftShiftOperation_right = Model.Name "right" + +-- | A C++ less-than-or-equal comparison expression (left <= right) +data LessEqualOperation = + LessEqualOperation { + lessEqualOperationLeft :: RelationalExpression, + lessEqualOperationRight :: ShiftExpression} + deriving (Eq, Ord, Read, Show) + +_LessEqualOperation = Model.Name "hydra.ext.cpp.syntax.LessEqualOperation" + +_LessEqualOperation_left = Model.Name "left" + +_LessEqualOperation_right = Model.Name "right" + +-- | A C++ less-than comparison expression (left < right) +data LessOperation = + LessOperation { + lessOperationLeft :: RelationalExpression, + lessOperationRight :: ShiftExpression} + deriving (Eq, Ord, Read, Show) + +_LessOperation = Model.Name "hydra.ext.cpp.syntax.LessOperation" + +_LessOperation_left = Model.Name "left" + +_LessOperation_right = Model.Name "right" + +-- | A C preprocessor #line directive +data LineDirective = + LineDirective { + lineDirectiveLineNumber :: Int, + lineDirectiveFilename :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_LineDirective = Model.Name "hydra.ext.cpp.syntax.LineDirective" + +_LineDirective_lineNumber = Model.Name "lineNumber" + +_LineDirective_filename = Model.Name "filename" + +-- | A declaration of a named std::vector type alias +data ListDeclaration = + ListDeclaration { + listDeclarationElementType :: TypeExpression, + listDeclarationName :: String} + deriving (Eq, Ord, Read, Show) + +_ListDeclaration = Model.Name "hydra.ext.cpp.syntax.ListDeclaration" + +_ListDeclaration_elementType = Model.Name "elementType" + +_ListDeclaration_name = Model.Name "name" + +-- | A C++ literal value +data Literal = + LiteralInteger IntegerLiteral | + LiteralFloating FloatingLiteral | + LiteralCharacter CharacterLiteral | + LiteralString StringLiteral | + LiteralBoolean BooleanLiteral | + LiteralNull + deriving (Eq, Ord, Read, Show) + +_Literal = Model.Name "hydra.ext.cpp.syntax.Literal" + +_Literal_integer = Model.Name "integer" + +_Literal_floating = Model.Name "floating" + +_Literal_character = Model.Name "character" + +_Literal_string = Model.Name "string" + +_Literal_boolean = Model.Name "boolean" + +_Literal_null = Model.Name "null" + +-- | A C++ logical-and-expression: an inclusive-or expression or a logical AND operation +data LogicalAndExpression = + LogicalAndExpressionInclusiveOr InclusiveOrExpression | + LogicalAndExpressionLogicalAnd LogicalAndOperation + deriving (Eq, Ord, Read, Show) + +_LogicalAndExpression = Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression" + +_LogicalAndExpression_inclusiveOr = Model.Name "inclusiveOr" + +_LogicalAndExpression_logicalAnd = Model.Name "logicalAnd" + +-- | A C++ logical AND expression (left && right) +data LogicalAndOperation = + LogicalAndOperation { + logicalAndOperationLeft :: LogicalAndExpression, + logicalAndOperationRight :: InclusiveOrExpression} + deriving (Eq, Ord, Read, Show) + +_LogicalAndOperation = Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation" + +_LogicalAndOperation_left = Model.Name "left" + +_LogicalAndOperation_right = Model.Name "right" + +-- | A C++ logical-or-expression: a logical-and expression or a logical OR operation +data LogicalOrExpression = + LogicalOrExpressionLogicalAnd LogicalAndExpression | + LogicalOrExpressionLogicalOr LogicalOrOperation + deriving (Eq, Ord, Read, Show) + +_LogicalOrExpression = Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression" + +_LogicalOrExpression_logicalAnd = Model.Name "logicalAnd" + +_LogicalOrExpression_logicalOr = Model.Name "logicalOr" + +-- | A C++ logical OR expression (left || right) +data LogicalOrOperation = + LogicalOrOperation { + logicalOrOperationLeft :: LogicalOrExpression, + logicalOrOperationRight :: LogicalAndExpression} + deriving (Eq, Ord, Read, Show) + +_LogicalOrOperation = Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation" + +_LogicalOrOperation_left = Model.Name "left" + +_LogicalOrOperation_right = Model.Name "right" + +-- | A C++ std::map literal, with a key type, a value type, and entries +data Map = + Map { + mapKeyType :: TypeExpression, + mapValueType :: TypeExpression, + mapEntries :: [MapEntry]} + deriving (Eq, Ord, Read, Show) + +_Map = Model.Name "hydra.ext.cpp.syntax.Map" + +_Map_keyType = Model.Name "keyType" + +_Map_valueType = Model.Name "valueType" + +_Map_entries = Model.Name "entries" + +-- | A declaration of a named std::map type alias +data MapDeclaration = + MapDeclaration { + mapDeclarationKeyType :: TypeExpression, + mapDeclarationValueType :: TypeExpression, + mapDeclarationName :: String} + deriving (Eq, Ord, Read, Show) + +_MapDeclaration = Model.Name "hydra.ext.cpp.syntax.MapDeclaration" + +_MapDeclaration_keyType = Model.Name "keyType" + +_MapDeclaration_valueType = Model.Name "valueType" + +_MapDeclaration_name = Model.Name "name" + +-- | A single key/value entry in a C++ map literal +data MapEntry = + MapEntry { + mapEntryKey :: Expression, + mapEntryValue :: Expression} + deriving (Eq, Ord, Read, Show) + +_MapEntry = Model.Name "hydra.ext.cpp.syntax.MapEntry" + +_MapEntry_key = Model.Name "key" + +_MapEntry_value = Model.Name "value" + +-- | A C++ member initializer in a constructor's initializer list +data MemInitializer = + MemInitializer { + memInitializerName :: String, + memInitializerArguments :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_MemInitializer = Model.Name "hydra.ext.cpp.syntax.MemInitializer" + +_MemInitializer_name = Model.Name "name" + +_MemInitializer_arguments = Model.Name "arguments" + +-- | A C++ member access expression (object.member) +data MemberAccessOperation = + MemberAccessOperation { + memberAccessOperationObject :: PostfixExpression, + memberAccessOperationMember :: String} + deriving (Eq, Ord, Read, Show) + +_MemberAccessOperation = Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation" + +_MemberAccessOperation_object = Model.Name "object" + +_MemberAccessOperation_member = Model.Name "member" + +-- | A single member declaration within a C++ class body +data MemberDeclaration = + MemberDeclarationFunction FunctionDeclaration | + MemberDeclarationVariable VariableDeclaration | + MemberDeclarationConstructor ConstructorDeclaration | + MemberDeclarationDestructor DestructorDeclaration | + MemberDeclarationNestedClass ClassDeclaration | + MemberDeclarationTemplate TemplateDeclaration + deriving (Eq, Ord, Read, Show) + +_MemberDeclaration = Model.Name "hydra.ext.cpp.syntax.MemberDeclaration" + +_MemberDeclaration_function = Model.Name "function" + +_MemberDeclaration_variable = Model.Name "variable" + +_MemberDeclaration_constructor = Model.Name "constructor" + +_MemberDeclaration_destructor = Model.Name "destructor" + +_MemberDeclaration_nestedClass = Model.Name "nestedClass" + +_MemberDeclaration_template = Model.Name "template" + +-- | An entry in a C++ class body: an access-level label or a member declaration +data MemberSpecification = + MemberSpecificationAccessLabel AccessSpecifier | + MemberSpecificationMember MemberDeclaration + deriving (Eq, Ord, Read, Show) + +_MemberSpecification = Model.Name "hydra.ext.cpp.syntax.MemberSpecification" + +_MemberSpecification_accessLabel = Model.Name "accessLabel" + +_MemberSpecification_member = Model.Name "member" + +-- | A C++ modulo expression (left % right) +data ModuloOperation = + ModuloOperation { + moduloOperationLeft :: MultiplicativeExpression, + moduloOperationRight :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_ModuloOperation = Model.Name "hydra.ext.cpp.syntax.ModuloOperation" + +_ModuloOperation_left = Model.Name "left" + +_ModuloOperation_right = Model.Name "right" + +-- | A C++ multiplicative-expression: a unary expression, a multiplication, a division, or a modulo +data MultiplicativeExpression = + MultiplicativeExpressionUnary UnaryExpression | + MultiplicativeExpressionMultiply MultiplyOperation | + MultiplicativeExpressionDivide DivideOperation | + MultiplicativeExpressionModulo ModuloOperation + deriving (Eq, Ord, Read, Show) + +_MultiplicativeExpression = Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression" + +_MultiplicativeExpression_unary = Model.Name "unary" + +_MultiplicativeExpression_multiply = Model.Name "multiply" + +_MultiplicativeExpression_divide = Model.Name "divide" + +_MultiplicativeExpression_modulo = Model.Name "modulo" + +-- | A C++ multiplication expression (left * right) +data MultiplyOperation = + MultiplyOperation { + multiplyOperationLeft :: MultiplicativeExpression, + multiplyOperationRight :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_MultiplyOperation = Model.Name "hydra.ext.cpp.syntax.MultiplyOperation" + +_MultiplyOperation_left = Model.Name "left" + +_MultiplyOperation_right = Model.Name "right" + +-- | A C++ namespace declaration enclosing a list of declarations +data NamespaceDeclaration = + NamespaceDeclaration { + namespaceDeclarationName :: String, + namespaceDeclarationDeclarations :: [Declaration]} + deriving (Eq, Ord, Read, Show) + +_NamespaceDeclaration = Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration" + +_NamespaceDeclaration_name = Model.Name "name" + +_NamespaceDeclaration_declarations = Model.Name "declarations" + +-- | A C++ inequality comparison expression (left != right) +data NotEqualOperation = + NotEqualOperation { + notEqualOperationLeft :: EqualityExpression, + notEqualOperationRight :: RelationalExpression} + deriving (Eq, Ord, Read, Show) + +_NotEqualOperation = Model.Name "hydra.ext.cpp.syntax.NotEqualOperation" + +_NotEqualOperation_left = Model.Name "left" + +_NotEqualOperation_right = Model.Name "right" + +-- | A C++ std::optional literal, with a value type and an optional contained value +data Optional = + Optional { + optionalValueType :: TypeExpression, + optionalValue :: (Maybe Expression)} + deriving (Eq, Ord, Read, Show) + +_Optional = Model.Name "hydra.ext.cpp.syntax.Optional" + +_Optional_valueType = Model.Name "valueType" + +_Optional_value = Model.Name "value" + +-- | A declaration of a named std::optional type alias +data OptionalDeclaration = + OptionalDeclaration { + optionalDeclarationValueType :: TypeExpression, + optionalDeclarationName :: String} + deriving (Eq, Ord, Read, Show) + +_OptionalDeclaration = Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration" + +_OptionalDeclaration_valueType = Model.Name "valueType" + +_OptionalDeclaration_name = Model.Name "name" + +-- | A set of lambda expressions combined via an overload pattern (e.g. a visitor helper) +newtype OverloadedLambdas = + OverloadedLambdas { + unOverloadedLambdas :: [LambdaExpression]} + deriving (Eq, Ord, Read, Show) + +_OverloadedLambdas = Model.Name "hydra.ext.cpp.syntax.OverloadedLambdas" + +-- | A C++ function or lambda parameter +data Parameter = + Parameter { + parameterType :: TypeExpression, + parameterName :: String, + parameterUnnamed :: Bool, + parameterDefaultValue :: (Maybe Expression)} + deriving (Eq, Ord, Read, Show) + +_Parameter = Model.Name "hydra.ext.cpp.syntax.Parameter" + +_Parameter_type = Model.Name "type" + +_Parameter_name = Model.Name "name" + +_Parameter_unnamed = Model.Name "unnamed" + +_Parameter_defaultValue = Model.Name "defaultValue" + +-- | A std::visit-style pattern match: a visitor applied to a variant expression +data PatternMatch = + PatternMatch { + patternMatchVisitor :: Visitor, + patternMatchVariant :: Expression} + deriving (Eq, Ord, Read, Show) + +_PatternMatch = Model.Name "hydra.ext.cpp.syntax.PatternMatch" + +_PatternMatch_visitor = Model.Name "visitor" + +_PatternMatch_variant = Model.Name "variant" + +-- | A C++ pointer member access expression (pointer->member) +data PointerMemberAccessOperation = + PointerMemberAccessOperation { + pointerMemberAccessOperationPointer :: PostfixExpression, + pointerMemberAccessOperationMember :: String} + deriving (Eq, Ord, Read, Show) + +_PointerMemberAccessOperation = Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation" + +_PointerMemberAccessOperation_pointer = Model.Name "pointer" + +_PointerMemberAccessOperation_member = Model.Name "member" + +-- | A C++ postfix-expression: a primary expression optionally followed by a postfix operation +data PostfixExpression = + PostfixExpressionPrimary PrimaryExpression | + PostfixExpressionSubscript SubscriptOperation | + PostfixExpressionFunctionCall FunctionCallOperation | + PostfixExpressionTemplateFunctionCall TemplateFunctionCallOperation | + PostfixExpressionMemberAccess MemberAccessOperation | + PostfixExpressionPointerMemberAccess PointerMemberAccessOperation | + PostfixExpressionPostIncrement PostfixExpression | + PostfixExpressionPostDecrement PostfixExpression + deriving (Eq, Ord, Read, Show) + +_PostfixExpression = Model.Name "hydra.ext.cpp.syntax.PostfixExpression" + +_PostfixExpression_primary = Model.Name "primary" + +_PostfixExpression_subscript = Model.Name "subscript" + +_PostfixExpression_functionCall = Model.Name "functionCall" + +_PostfixExpression_templateFunctionCall = Model.Name "templateFunctionCall" + +_PostfixExpression_memberAccess = Model.Name "memberAccess" + +_PostfixExpression_pointerMemberAccess = Model.Name "pointerMemberAccess" + +_PostfixExpression_postIncrement = Model.Name "postIncrement" + +_PostfixExpression_postDecrement = Model.Name "postDecrement" + +-- | A C preprocessor #pragma directive +data PragmaDirective = + PragmaDirective { + pragmaDirectiveContent :: String} + deriving (Eq, Ord, Read, Show) + +_PragmaDirective = Model.Name "hydra.ext.cpp.syntax.PragmaDirective" + +_PragmaDirective_content = Model.Name "content" + +-- | A C preprocessor directive +data PreprocessorDirective = + PreprocessorDirectiveInclude IncludeDirective | + PreprocessorDirectivePragma PragmaDirective | + PreprocessorDirectiveDefine DefineDirective | + PreprocessorDirectiveUndef UndefDirective | + PreprocessorDirectiveIfdef IfdefDirective | + PreprocessorDirectiveIfndef IfndefDirective | + PreprocessorDirectiveIf IfDirective | + PreprocessorDirectiveElif ElifDirective | + PreprocessorDirectiveElse ElseDirective | + PreprocessorDirectiveEndif EndifDirective | + PreprocessorDirectiveLine LineDirective | + PreprocessorDirectiveError ErrorDirective | + PreprocessorDirectiveWarning WarningDirective + deriving (Eq, Ord, Read, Show) + +_PreprocessorDirective = Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective" + +_PreprocessorDirective_include = Model.Name "include" + +_PreprocessorDirective_pragma = Model.Name "pragma" + +_PreprocessorDirective_define = Model.Name "define" + +_PreprocessorDirective_undef = Model.Name "undef" + +_PreprocessorDirective_ifdef = Model.Name "ifdef" + +_PreprocessorDirective_ifndef = Model.Name "ifndef" + +_PreprocessorDirective_if = Model.Name "if" + +_PreprocessorDirective_elif = Model.Name "elif" + +_PreprocessorDirective_else = Model.Name "else" + +_PreprocessorDirective_endif = Model.Name "endif" + +_PreprocessorDirective_line = Model.Name "line" + +_PreprocessorDirective_error = Model.Name "error" + +_PreprocessorDirective_warning = Model.Name "warning" + +-- | A C++ primary-expression: an identifier, a literal, a parenthesized expression, or a lambda +data PrimaryExpression = + PrimaryExpressionIdentifier String | + PrimaryExpressionLiteral Literal | + PrimaryExpressionParenthesized Expression | + PrimaryExpressionLambda LambdaExpression + deriving (Eq, Ord, Read, Show) + +_PrimaryExpression = Model.Name "hydra.ext.cpp.syntax.PrimaryExpression" + +_PrimaryExpression_identifier = Model.Name "identifier" + +_PrimaryExpression_literal = Model.Name "literal" + +_PrimaryExpression_parenthesized = Model.Name "parenthesized" + +_PrimaryExpression_lambda = Model.Name "lambda" + +-- | A declaration of a product type as a C++ struct with named fields +data ProductDeclaration = + ProductDeclaration { + productDeclarationName :: String, + productDeclarationFields :: [VariableDeclaration]} + deriving (Eq, Ord, Read, Show) + +_ProductDeclaration = Model.Name "hydra.ext.cpp.syntax.ProductDeclaration" + +_ProductDeclaration_name = Model.Name "name" + +_ProductDeclaration_fields = Model.Name "fields" + +-- | A complete C++ source or header file: preprocessor directives, includes, and declarations +data Program = + Program { + programPreprocessorDirectives :: [PreprocessorDirective], + programIncludes :: [IncludeDirective], + programDeclarations :: [Declaration]} + deriving (Eq, Ord, Read, Show) + +_Program = Model.Name "hydra.ext.cpp.syntax.Program" + +_Program_preprocessorDirectives = Model.Name "preprocessorDirectives" + +_Program_includes = Model.Name "includes" + +_Program_declarations = Model.Name "declarations" + +-- | A C++ namespace-qualified identifier (namespace::name) +data QualifiedIdentifier = + QualifiedIdentifier { + qualifiedIdentifierNamespace :: String, + qualifiedIdentifierName :: String} + deriving (Eq, Ord, Read, Show) + +_QualifiedIdentifier = Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier" + +_QualifiedIdentifier_namespace = Model.Name "namespace" + +_QualifiedIdentifier_name = Model.Name "name" + +-- | A C++ type expression qualified by const, a reference, or a pointer +data QualifiedType = + QualifiedType { + qualifiedTypeBaseType :: TypeExpression, + qualifiedTypeQualifier :: TypeQualifier} + deriving (Eq, Ord, Read, Show) + +_QualifiedType = Model.Name "hydra.ext.cpp.syntax.QualifiedType" + +_QualifiedType_baseType = Model.Name "baseType" + +_QualifiedType_qualifier = Model.Name "qualifier" + +-- | A C++ range-based for statement +data RangeForStatement = + RangeForStatement { + rangeForStatementType :: TypeExpression, + rangeForStatementVariable :: String, + rangeForStatementRange :: Expression, + rangeForStatementBody :: Statement} + deriving (Eq, Ord, Read, Show) + +_RangeForStatement = Model.Name "hydra.ext.cpp.syntax.RangeForStatement" + +_RangeForStatement_type = Model.Name "type" + +_RangeForStatement_variable = Model.Name "variable" + +_RangeForStatement_range = Model.Name "range" + +_RangeForStatement_body = Model.Name "body" + +-- | A C++ relational-expression: a shift expression or a relational comparison +data RelationalExpression = + RelationalExpressionShift ShiftExpression | + RelationalExpressionLess LessOperation | + RelationalExpressionGreater GreaterOperation | + RelationalExpressionLessEqual LessEqualOperation | + RelationalExpressionGreaterEqual GreaterEqualOperation + deriving (Eq, Ord, Read, Show) + +_RelationalExpression = Model.Name "hydra.ext.cpp.syntax.RelationalExpression" + +_RelationalExpression_shift = Model.Name "shift" + +_RelationalExpression_less = Model.Name "less" + +_RelationalExpression_greater = Model.Name "greater" + +_RelationalExpression_lessEqual = Model.Name "lessEqual" + +_RelationalExpression_greaterEqual = Model.Name "greaterEqual" + +-- | A C++ right shift expression (left >> right) +data RightShiftOperation = + RightShiftOperation { + rightShiftOperationLeft :: ShiftExpression, + rightShiftOperationRight :: AdditiveExpression} + deriving (Eq, Ord, Read, Show) + +_RightShiftOperation = Model.Name "hydra.ext.cpp.syntax.RightShiftOperation" + +_RightShiftOperation_left = Model.Name "left" + +_RightShiftOperation_right = Model.Name "right" + +-- | A C++ if statement, with an optional else branch +data SelectionStatement = + SelectionStatement { + selectionStatementCondition :: Expression, + selectionStatementThenBranch :: Statement, + selectionStatementElseBranch :: (Maybe Statement)} + deriving (Eq, Ord, Read, Show) + +_SelectionStatement = Model.Name "hydra.ext.cpp.syntax.SelectionStatement" + +_SelectionStatement_condition = Model.Name "condition" + +_SelectionStatement_thenBranch = Model.Name "thenBranch" + +_SelectionStatement_elseBranch = Model.Name "elseBranch" + +-- | A C++ std::set literal, with an element type and elements +data Set = + Set { + setElementType :: TypeExpression, + setElements :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_Set = Model.Name "hydra.ext.cpp.syntax.Set" + +_Set_elementType = Model.Name "elementType" + +_Set_elements = Model.Name "elements" + +-- | A declaration of a named std::set type alias +data SetDeclaration = + SetDeclaration { + setDeclarationElementType :: TypeExpression, + setDeclarationName :: String} + deriving (Eq, Ord, Read, Show) + +_SetDeclaration = Model.Name "hydra.ext.cpp.syntax.SetDeclaration" + +_SetDeclaration_elementType = Model.Name "elementType" + +_SetDeclaration_name = Model.Name "name" + +-- | A C++ shift-expression: an additive expression, a left shift, or a right shift +data ShiftExpression = + ShiftExpressionAdditive AdditiveExpression | + ShiftExpressionLeftShift LeftShiftOperation | + ShiftExpressionRightShift RightShiftOperation + deriving (Eq, Ord, Read, Show) + +_ShiftExpression = Model.Name "hydra.ext.cpp.syntax.ShiftExpression" + +_ShiftExpression_additive = Model.Name "additive" + +_ShiftExpression_leftShift = Model.Name "leftShift" + +_ShiftExpression_rightShift = Model.Name "rightShift" + +-- | A C++ sizeof expression applied to a type +newtype SizeofExpression = + SizeofExpression { + unSizeofExpression :: TypeExpression} + deriving (Eq, Ord, Read, Show) + +_SizeofExpression = Model.Name "hydra.ext.cpp.syntax.SizeofExpression" + +-- | A C++ statement +data Statement = + StatementLabeled LabeledStatement | + StatementCompound CompoundStatement | + StatementSelection SelectionStatement | + StatementSwitch SwitchStatement | + StatementIteration IterationStatement | + StatementJump JumpStatement | + StatementDeclaration VariableDeclaration | + StatementExpression Expression + deriving (Eq, Ord, Read, Show) + +_Statement = Model.Name "hydra.ext.cpp.syntax.Statement" + +_Statement_labeled = Model.Name "labeled" + +_Statement_compound = Model.Name "compound" + +_Statement_selection = Model.Name "selection" + +_Statement_switch = Model.Name "switch" + +_Statement_iteration = Model.Name "iteration" + +_Statement_jump = Model.Name "jump" + +_Statement_declaration = Model.Name "declaration" + +_Statement_expression = Model.Name "expression" + +-- | A C++ string literal +newtype StringLiteral = + StringLiteral { + unStringLiteral :: String} + deriving (Eq, Ord, Read, Show) + +_StringLiteral = Model.Name "hydra.ext.cpp.syntax.StringLiteral" + +-- | A C++ array subscript expression (array[index]) +data SubscriptOperation = + SubscriptOperation { + subscriptOperationArray :: PostfixExpression, + subscriptOperationIndex :: Expression} + deriving (Eq, Ord, Read, Show) + +_SubscriptOperation = Model.Name "hydra.ext.cpp.syntax.SubscriptOperation" + +_SubscriptOperation_array = Model.Name "array" + +_SubscriptOperation_index = Model.Name "index" + +-- | A C++ subtraction expression (left - right) +data SubtractOperation = + SubtractOperation { + subtractOperationLeft :: AdditiveExpression, + subtractOperationRight :: MultiplicativeExpression} + deriving (Eq, Ord, Read, Show) + +_SubtractOperation = Model.Name "hydra.ext.cpp.syntax.SubtractOperation" + +_SubtractOperation_left = Model.Name "left" + +_SubtractOperation_right = Model.Name "right" + +-- | A C++ switch statement +data SwitchStatement = + SwitchStatement { + switchStatementValue :: Expression, + switchStatementCases :: [CaseStatement]} + deriving (Eq, Ord, Read, Show) + +_SwitchStatement = Model.Name "hydra.ext.cpp.syntax.SwitchStatement" + +_SwitchStatement_value = Model.Name "value" + +_SwitchStatement_cases = Model.Name "cases" + +-- | A single argument to a C++ template instantiation: a type or a value +data TemplateArgument = + TemplateArgumentType TypeExpression | + TemplateArgumentValue Expression + deriving (Eq, Ord, Read, Show) + +_TemplateArgument = Model.Name "hydra.ext.cpp.syntax.TemplateArgument" + +_TemplateArgument_type = Model.Name "type" + +_TemplateArgument_value = Model.Name "value" + +-- | A C++ template declaration wrapping a class or function declaration +data TemplateDeclaration = + TemplateDeclaration { + templateDeclarationInline :: Bool, + templateDeclarationParameters :: [String], + templateDeclarationDeclaration :: Declaration} + deriving (Eq, Ord, Read, Show) + +_TemplateDeclaration = Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration" + +_TemplateDeclaration_inline = Model.Name "inline" + +_TemplateDeclaration_parameters = Model.Name "parameters" + +_TemplateDeclaration_declaration = Model.Name "declaration" + +-- | A C++ explicit template function call (func(arguments)) +data TemplateFunctionCallOperation = + TemplateFunctionCallOperation { + templateFunctionCallOperationFunction :: PostfixExpression, + templateFunctionCallOperationTemplateArguments :: [TemplateArgument], + templateFunctionCallOperationArguments :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_TemplateFunctionCallOperation = Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation" + +_TemplateFunctionCallOperation_function = Model.Name "function" + +_TemplateFunctionCallOperation_templateArguments = Model.Name "templateArguments" + +_TemplateFunctionCallOperation_arguments = Model.Name "arguments" + +-- | A C++ template instantiation type (e.g. std::vector) +data TemplateType = + TemplateType { + templateTypeName :: String, + templateTypeArguments :: [TemplateArgument]} + deriving (Eq, Ord, Read, Show) + +_TemplateType = Model.Name "hydra.ext.cpp.syntax.TemplateType" + +_TemplateType_name = Model.Name "name" + +_TemplateType_arguments = Model.Name "arguments" + +-- | A C++ ternary conditional expression (condition ? trueExpr : falseExpr) +data TernaryExpression = + TernaryExpression { + ternaryExpressionCondition :: LogicalOrExpression, + ternaryExpressionTrueExpr :: Expression, + ternaryExpressionFalseExpr :: ConditionalExpression} + deriving (Eq, Ord, Read, Show) + +_TernaryExpression = Model.Name "hydra.ext.cpp.syntax.TernaryExpression" + +_TernaryExpression_condition = Model.Name "condition" + +_TernaryExpression_trueExpr = Model.Name "trueExpr" + +_TernaryExpression_falseExpr = Model.Name "falseExpr" + +-- | A C++ type expression +data TypeExpression = + TypeExpressionBasic BasicType | + TypeExpressionQualified QualifiedType | + TypeExpressionTemplate TemplateType | + TypeExpressionFunction FunctionType | + TypeExpressionAuto + deriving (Eq, Ord, Read, Show) + +_TypeExpression = Model.Name "hydra.ext.cpp.syntax.TypeExpression" + +_TypeExpression_basic = Model.Name "basic" + +_TypeExpression_qualified = Model.Name "qualified" + +_TypeExpression_template = Model.Name "template" + +_TypeExpression_function = Model.Name "function" + +_TypeExpression_auto = Model.Name "auto" + +-- | A C++ type qualifier: const, lvalue reference, rvalue reference, or pointer +data TypeQualifier = + TypeQualifierConst | + TypeQualifierLvalueRef | + TypeQualifierRvalueRef | + TypeQualifierPointer + deriving (Eq, Ord, Read, Show) + +_TypeQualifier = Model.Name "hydra.ext.cpp.syntax.TypeQualifier" + +_TypeQualifier_const = Model.Name "const" + +_TypeQualifier_lvalueRef = Model.Name "lvalueRef" + +_TypeQualifier_rvalueRef = Model.Name "rvalueRef" + +_TypeQualifier_pointer = Model.Name "pointer" + +-- | A C++ typedef or using type alias declaration +data TypedefDeclaration = + TypedefDeclaration { + typedefDeclarationName :: String, + typedefDeclarationType :: TypeExpression, + typedefDeclarationIsUsing :: Bool} + deriving (Eq, Ord, Read, Show) + +_TypedefDeclaration = Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration" + +_TypedefDeclaration_name = Model.Name "name" + +_TypedefDeclaration_type = Model.Name "type" + +_TypedefDeclaration_isUsing = Model.Name "isUsing" + +-- | A C++ unary-expression: a postfix expression, a unary operation, or a sizeof expression +data UnaryExpression = + UnaryExpressionPostfix PostfixExpression | + UnaryExpressionUnaryOp UnaryOperation | + UnaryExpressionSizeof SizeofExpression + deriving (Eq, Ord, Read, Show) + +_UnaryExpression = Model.Name "hydra.ext.cpp.syntax.UnaryExpression" + +_UnaryExpression_postfix = Model.Name "postfix" + +_UnaryExpression_unaryOp = Model.Name "unaryOp" + +_UnaryExpression_sizeof = Model.Name "sizeof" + +-- | A C++ unary operation applied to an operand (e.g. -x, !x, *x) +data UnaryOperation = + UnaryOperation { + unaryOperationOperator :: UnaryOperator, + unaryOperationOperand :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_UnaryOperation = Model.Name "hydra.ext.cpp.syntax.UnaryOperation" + +_UnaryOperation_operator = Model.Name "operator" + +_UnaryOperation_operand = Model.Name "operand" + +-- | A C++ unary operator +data UnaryOperator = + UnaryOperatorPlus | + UnaryOperatorMinus | + UnaryOperatorLogicalNot | + UnaryOperatorBitwiseNot | + UnaryOperatorDereference | + UnaryOperatorAddressOf | + UnaryOperatorPreIncrement | + UnaryOperatorPreDecrement + deriving (Eq, Ord, Read, Show) + +_UnaryOperator = Model.Name "hydra.ext.cpp.syntax.UnaryOperator" + +_UnaryOperator_plus = Model.Name "plus" + +_UnaryOperator_minus = Model.Name "minus" + +_UnaryOperator_logicalNot = Model.Name "logicalNot" + +_UnaryOperator_bitwiseNot = Model.Name "bitwiseNot" + +_UnaryOperator_dereference = Model.Name "dereference" + +_UnaryOperator_addressOf = Model.Name "addressOf" + +_UnaryOperator_preIncrement = Model.Name "preIncrement" + +_UnaryOperator_preDecrement = Model.Name "preDecrement" + +-- | A C preprocessor #undef directive +data UndefDirective = + UndefDirective { + undefDirectiveName :: String} + deriving (Eq, Ord, Read, Show) + +_UndefDirective = Model.Name "hydra.ext.cpp.syntax.UndefDirective" + +_UndefDirective_name = Model.Name "name" + +-- | A C++ variable declaration, with an optional type (for auto) and initializer +data VariableDeclaration = + VariableDeclaration { + variableDeclarationType :: (Maybe TypeExpression), + variableDeclarationName :: String, + variableDeclarationInitializer :: (Maybe Expression), + variableDeclarationIsAuto :: Bool} + deriving (Eq, Ord, Read, Show) + +_VariableDeclaration = Model.Name "hydra.ext.cpp.syntax.VariableDeclaration" + +_VariableDeclaration_type = Model.Name "type" + +_VariableDeclaration_name = Model.Name "name" + +_VariableDeclaration_initializer = Model.Name "initializer" + +_VariableDeclaration_isAuto = Model.Name "isAuto" + +-- | A declaration of a named std::variant type alias over a list of member types +data VariantDeclaration = + VariantDeclaration { + variantDeclarationTypes :: [TypeExpression], + variantDeclarationName :: String} + deriving (Eq, Ord, Read, Show) + +_VariantDeclaration = Model.Name "hydra.ext.cpp.syntax.VariantDeclaration" + +_VariantDeclaration_types = Model.Name "types" + +_VariantDeclaration_name = Model.Name "name" + +-- | A C++ std::vector literal, with an element type and elements +data Vector = + Vector { + vectorElementType :: TypeExpression, + vectorElements :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_Vector = Model.Name "hydra.ext.cpp.syntax.Vector" + +_Vector_elementType = Model.Name "elementType" + +_Vector_elements = Model.Name "elements" + +-- | A C++ visitor used in a pattern match: a single lambda or a set of overloaded lambdas +data Visitor = + VisitorLambda LambdaExpression | + VisitorOverloaded OverloadedLambdas + deriving (Eq, Ord, Read, Show) + +_Visitor = Model.Name "hydra.ext.cpp.syntax.Visitor" + +_Visitor_lambda = Model.Name "lambda" + +_Visitor_overloaded = Model.Name "overloaded" + +-- | A C preprocessor #warning directive +data WarningDirective = + WarningDirective { + warningDirectiveMessage :: String} + deriving (Eq, Ord, Read, Show) + +_WarningDirective = Model.Name "hydra.ext.cpp.syntax.WarningDirective" + +_WarningDirective_message = Model.Name "message" + +-- | A C++ while statement +data WhileStatement = + WhileStatement { + whileStatementCondition :: Expression, + whileStatementBody :: Statement} + deriving (Eq, Ord, Read, Show) + +_WhileStatement = Model.Name "hydra.ext.cpp.syntax.WhileStatement" + +_WhileStatement_condition = Model.Name "condition" + +_WhileStatement_body = Model.Name "body" diff --git a/src/main/haskell/Hydra/Ext/Cpp/Utils.hs b/src/main/haskell/Hydra/Ext/Cpp/Utils.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Cpp/Utils.hs @@ -0,0 +1,310 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | C++ utilities for constructing C++ syntax trees + +module Hydra.Ext.Cpp.Utils where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Cpp.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Create a const reference parameter +constParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter +constParameter name typ = + Syntax.Parameter { + Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = typ, + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst})), + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})), + Syntax.parameterName = name, + Syntax.parameterUnnamed = False, + Syntax.parameterDefaultValue = Nothing} + +-- | Create a C++ class declaration +cppClassDeclaration :: String -> [Syntax.BaseSpecifier] -> Maybe Syntax.ClassBody -> Syntax.Declaration +cppClassDeclaration name baseSpecs mbody = + Syntax.DeclarationClass (Syntax.ClassDeclaration { + Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { + Syntax.classSpecifierKey = Syntax.ClassKeyClass, + Syntax.classSpecifierName = name, + Syntax.classSpecifierInheritance = baseSpecs}, + Syntax.classDeclarationBody = mbody}) + +-- | Create a C++ enum class declaration +cppEnumDeclaration :: String -> Maybe Syntax.ClassBody -> Syntax.Declaration +cppEnumDeclaration name mbody = + Syntax.DeclarationClass (Syntax.ClassDeclaration { + Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { + Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, + Syntax.classSpecifierName = name, + Syntax.classSpecifierInheritance = []}, + Syntax.classDeclarationBody = mbody}) + +-- | Create a C++ enum class forward declaration +cppEnumForwardDeclaration :: String -> Syntax.Declaration +cppEnumForwardDeclaration name = + Syntax.DeclarationClass (Syntax.ClassDeclaration { + Syntax.classDeclarationSpecifier = Syntax.ClassSpecifier { + Syntax.classSpecifierKey = Syntax.ClassKeyEnumClass, + Syntax.classSpecifierName = name, + Syntax.classSpecifierInheritance = []}, + Syntax.classDeclarationBody = Nothing}) + +-- | Convert a PostfixExpression to an Expression +cppPostfixExpressionToCppExpression :: Syntax.PostfixExpression -> Syntax.Expression +cppPostfixExpressionToCppExpression pf = cppUnaryExpressionToCppExpression (Syntax.UnaryExpressionPostfix pf) + +-- | Convert a PrimaryExpression to an Expression +cppPrimaryExpressionToCppExpression :: Syntax.PrimaryExpression -> Syntax.Expression +cppPrimaryExpressionToCppExpression prim = cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary prim) + +-- | Convert a UnaryExpression to an Expression +cppUnaryExpressionToCppExpression :: Syntax.UnaryExpression -> Syntax.Expression +cppUnaryExpressionToCppExpression ue = + Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionLogicalOr (cppUnaryExpressionToCppLogicalOrExpression ue))) + +-- | Convert a UnaryExpression to a LogicalOrExpression +cppUnaryExpressionToCppLogicalOrExpression :: Syntax.UnaryExpression -> Syntax.LogicalOrExpression +cppUnaryExpressionToCppLogicalOrExpression ue = + Syntax.LogicalOrExpressionLogicalAnd (Syntax.LogicalAndExpressionInclusiveOr (Syntax.InclusiveOrExpressionExclusiveOr (Syntax.ExclusiveOrExpressionAnd (Syntax.AndExpressionEquality (Syntax.EqualityExpressionRelational (Syntax.RelationalExpressionShift (Syntax.ShiftExpressionAdditive (Syntax.AdditiveExpressionMultiplicative (Syntax.MultiplicativeExpressionUnary ue))))))))) + +-- | Create a cast expression +createCastExpr :: t0 -> Syntax.Expression -> Syntax.Expression +createCastExpr targetType expr = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized (cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized expr))) + +-- | Create a compound statement +createCompoundStmt :: [Syntax.Statement] -> Syntax.CompoundStatement +createCompoundStmt stmts = Syntax.CompoundStatement stmts + +-- | Create a const reference type +createConstRefType :: Syntax.TypeExpression -> Syntax.TypeExpression +createConstRefType baseType = createReferenceType (createConstType baseType) + +-- | Create a const-qualified type +createConstType :: Syntax.TypeExpression -> Syntax.TypeExpression +createConstType baseType = createQualifiedType baseType Syntax.TypeQualifierConst + +-- | Create a constructor body (default if no params, empty otherwise) +createConstructorBody :: [t0] -> Syntax.FunctionBody +createConstructorBody params = Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault emptyFunctionBody + +-- | Create an enum access expression +createEnumAccessExpr :: String -> String -> Syntax.Expression +createEnumAccessExpr enumName valueName = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { + Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier enumName)), + Syntax.memberAccessOperationMember = valueName})) + +-- | Create a function call expression +createFunctionCallExpr :: String -> [Syntax.Expression] -> Syntax.Expression +createFunctionCallExpr funcName args = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier funcName)), + Syntax.functionCallOperationArguments = args})) + +-- | Create a header file with pragma once +createHeaderFile :: [Syntax.IncludeDirective] -> [Syntax.Declaration] -> Syntax.Program +createHeaderFile includes decls = + Syntax.Program { + Syntax.programPreprocessorDirectives = [ + Syntax.PreprocessorDirectivePragma (Syntax.PragmaDirective { + Syntax.pragmaDirectiveContent = "once"})], + Syntax.programIncludes = includes, + Syntax.programDeclarations = decls} + +-- | Create an identifier expression +createIdentifierExpr :: String -> Syntax.Expression +createIdentifierExpr name = cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier name) + +-- | Create a lambda expression +createLambdaExpr :: [Syntax.Parameter] -> Syntax.Expression -> Syntax.Expression +createLambdaExpr params body = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionLambda (Syntax.LambdaExpression { + Syntax.lambdaExpressionCaptures = (Syntax.CaptureListCaptures []), + Syntax.lambdaExpressionParameters = params, + Syntax.lambdaExpressionReturnType = Nothing, + Syntax.lambdaExpressionBody = (Syntax.CompoundStatement [ + Syntax.StatementExpression body])}))) + +-- | Create a boolean literal expression +createLiteralBoolExpr :: Bool -> Syntax.Expression +createLiteralBoolExpr val = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralBoolean (Syntax.BooleanLiteral val))) + +-- | Create an integer literal expression +createLiteralIntExpr :: Integer -> Syntax.Expression +createLiteralIntExpr val = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteralDecimal val))) + +-- | Create a string literal expression +createLiteralStringExpr :: String -> Syntax.Expression +createLiteralStringExpr val = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralString (Syntax.StringLiteral val))) + +-- | Create a member access expression +createMemberAccessExpr :: Syntax.Expression -> String -> Syntax.Expression +createMemberAccessExpr objExpr member = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { + Syntax.memberAccessOperationObject = (extractPostfixExpression objExpr), + Syntax.memberAccessOperationMember = member})) + +-- | Create a qualified type with a qualifier +createQualifiedType :: Syntax.TypeExpression -> Syntax.TypeQualifier -> Syntax.TypeExpression +createQualifiedType baseType qualifier = + Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = baseType, + Syntax.qualifiedTypeQualifier = qualifier}) + +-- | Create a reference type +createReferenceType :: Syntax.TypeExpression -> Syntax.TypeExpression +createReferenceType baseType = createQualifiedType baseType Syntax.TypeQualifierLvalueRef + +-- | Create a return statement with a value +createReturnStmt :: Syntax.Expression -> Syntax.Statement +createReturnStmt expr = Syntax.StatementJump (Syntax.JumpStatementReturnValue expr) + +-- | Create a void return statement +createReturnVoidStmt :: Syntax.Statement +createReturnVoidStmt = Syntax.StatementJump Syntax.JumpStatementReturnVoid + +-- | Create a template type +createTemplateType :: String -> [Syntax.TypeExpression] -> Syntax.TypeExpression +createTemplateType name args = + Syntax.TypeExpressionTemplate (Syntax.TemplateType { + Syntax.templateTypeName = name, + Syntax.templateTypeArguments = (Lists.map (\a -> Syntax.TemplateArgumentType a) args)}) + +-- | Create a *this expression +createThisExpr :: Syntax.Expression +createThisExpr = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "*this")) + +-- | Create a throw statement +createThrowStmt :: String -> Syntax.Expression -> Syntax.Statement +createThrowStmt exceptionType arg = + Syntax.StatementJump (Syntax.JumpStatementThrow (createFunctionCallExpr exceptionType [ + arg])) + +-- | Create a typeid(...).name() call expression +createTypeIdNameCall :: Syntax.Expression +createTypeIdNameCall = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionMemberAccess (Syntax.MemberAccessOperation { + Syntax.memberAccessOperationObject = (Syntax.PostfixExpressionFunctionCall (Syntax.FunctionCallOperation { + Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "typeid")), + Syntax.functionCallOperationArguments = [ + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionParenthesized createThisExpr)]})), + Syntax.memberAccessOperationMember = "name"})), + Syntax.functionCallOperationArguments = []})) + +-- | Create a type name expression +createTypeNameExpr :: String -> Syntax.Expression +createTypeNameExpr typeName = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier typeName)) + +-- | Create a variant expression +createVariantExpr :: Syntax.Expression +createVariantExpr = + cppPostfixExpressionToCppExpression (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "variant")) + +-- | An empty function body +emptyFunctionBody :: Syntax.FunctionBody +emptyFunctionBody = Syntax.FunctionBodyCompound (Syntax.CompoundStatement []) + +-- | Extract the PostfixExpression from a fully-wrapped Expression +extractPostfixExpression :: Syntax.Expression -> Syntax.PostfixExpression +extractPostfixExpression expr = + case expr of + Syntax.ExpressionAssignment v0 -> case v0 of + Syntax.AssignmentExpressionConditional v1 -> case v1 of + Syntax.ConditionalExpressionLogicalOr v2 -> case v2 of + Syntax.LogicalOrExpressionLogicalAnd v3 -> case v3 of + Syntax.LogicalAndExpressionInclusiveOr v4 -> case v4 of + Syntax.InclusiveOrExpressionExclusiveOr v5 -> case v5 of + Syntax.ExclusiveOrExpressionAnd v6 -> case v6 of + Syntax.AndExpressionEquality v7 -> case v7 of + Syntax.EqualityExpressionRelational v8 -> case v8 of + Syntax.RelationalExpressionShift v9 -> case v9 of + Syntax.ShiftExpressionAdditive v10 -> case v10 of + Syntax.AdditiveExpressionMultiplicative v11 -> case v11 of + Syntax.MultiplicativeExpressionUnary v12 -> case v12 of + Syntax.UnaryExpressionPostfix v13 -> v13 + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + _ -> Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier "error") + +-- | Protected access specifier member specification +memberSpecificationProtected :: Syntax.MemberSpecification +memberSpecificationProtected = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierProtected + +-- | Public access specifier member specification +memberSpecificationPublic :: Syntax.MemberSpecification +memberSpecificationPublic = Syntax.MemberSpecificationAccessLabel Syntax.AccessSpecifierPublic + +-- | Create a string expression +stringExpression :: String -> Syntax.Expression +stringExpression s = + cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionLiteral (Syntax.LiteralString (Syntax.StringLiteral s))) + +-- | Add const qualifier to a type +toConstType :: Syntax.TypeExpression -> Syntax.TypeExpression +toConstType baseType = + Syntax.TypeExpressionQualified (Syntax.QualifiedType { + Syntax.qualifiedTypeBaseType = baseType, + Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierConst}) + +-- | Create an unnamed parameter +unnamedParameter :: String -> Syntax.TypeExpression -> Syntax.Parameter +unnamedParameter name typ = + Syntax.Parameter { + Syntax.parameterType = typ, + Syntax.parameterName = name, + Syntax.parameterUnnamed = True, + Syntax.parameterDefaultValue = Nothing} diff --git a/src/main/haskell/Hydra/Ext/Csharp/Language.hs b/src/main/haskell/Hydra/Ext/Csharp/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Csharp/Language.hs @@ -0,0 +1,249 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints and reserved words for C Sharp (C#) + +module Hydra.Ext.Csharp.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | Language constraints for C Sharp (C#) +csharpLanguage :: Coders.Language +csharpLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.csharp"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "cs")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBinary, + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = + Sets.fromList [ + Model.FloatTypeFloat32, + Model.FloatTypeFloat64] + integerTypes = + Sets.fromList [ + Model.IntegerTypeInt8, + Model.IntegerTypeInt16, + Model.IntegerTypeInt32, + Model.IntegerTypeInt64, + Model.IntegerTypeUint8, + Model.IntegerTypeUint16, + Model.IntegerTypeUint32, + Model.IntegerTypeUint64] + termVariants = + Sets.fromList [ + Variants.TermVariantApplication, + Variants.TermVariantCases, + Variants.TermVariantLambda, + Variants.TermVariantProject, + Variants.TermVariantUnwrap, + Variants.TermVariantTypeApplication, + Variants.TermVariantTypeLambda, + Variants.TermVariantLet, + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantMap, + Variants.TermVariantOptional, + Variants.TermVariantRecord, + Variants.TermVariantSet, + Variants.TermVariantInject, + Variants.TermVariantVariable, + Variants.TermVariantWrap] + typeVariants = + Sets.fromList [ + Variants.TypeVariantAnnotated, + Variants.TypeVariantApplication, + Variants.TypeVariantFunction, + Variants.TypeVariantForall, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantOptional, + Variants.TypeVariantRecord, + Variants.TypeVariantSet, + Variants.TypeVariantUnion, + Variants.TypeVariantVariable, + Variants.TypeVariantWrap] + typePredicate = \_ -> True + +-- | A set of reserved words in C#. Both the "keywords" and "contextual keywords" are drawn from section 6.4.4 of the C# documentation: +-- | https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#64-tokens +csharpReservedWords :: S.Set String +csharpReservedWords = + Sets.fromList (Lists.concat [ + keywords, + contextualKeywords]) + where + keywords = + [ + "DEFAULT", + "FALSE", + "NULL", + "TRUE", + "abstract", + "as", + "base", + "bool", + "break", + "byte", + "case", + "catch", + "char", + "checked", + "class", + "const", + "continue", + "decimal", + "delegate", + "do", + "double", + "else", + "enum", + "event", + "explicit", + "extern", + "finally", + "fixed", + "float", + "for", + "foreach", + "goto", + "if", + "implicit", + "in", + "int", + "interface", + "internal", + "is", + "lock", + "long", + "namespace", + "new", + "object", + "operator", + "out", + "override", + "params", + "private", + "protected", + "public", + "readonly", + "ref", + "return", + "sbyte", + "sealed", + "short", + "sizeof", + "stackalloc", + "static", + "string", + "struct", + "switch", + "this", + "throw", + "try", + "typeof", + "uint", + "ulong", + "unchecked", + "unsafe", + "ushort", + "using", + "virtual", + "void", + "volatile", + "while"] + contextualKeywords = + [ + "add", + "alias", + "ascending", + "async", + "await", + "by", + "descending", + "dynamic", + "equals", + "from", + "get", + "global", + "group", + "into", + "join", + "let", + "nameof", + "on", + "orderby", + "partial", + "remove", + "select", + "set", + "unmanaged", + "value", + "var", + "when", + "where", + "yield"] diff --git a/src/main/haskell/Hydra/Ext/Csharp/Syntax.hs b/src/main/haskell/Hydra/Ext/Csharp/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Csharp/Syntax.hs @@ -0,0 +1,5297 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A C# syntax module based on the ANTLR grammar dated 02/07/2024 and available at: +-- | https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/grammar + +module Hydra.Ext.Csharp.Syntax where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | The body of a property or indexer accessor: a block, an expression, or empty (abstract). +data AccessorBody = + AccessorBodyBlock Block | + AccessorBodyExpression Expression | + AccessorBodyEmpty + deriving (Eq, Ord, Read, Show) + +_AccessorBody = Model.Name "hydra.ext.csharp.syntax.AccessorBody" + +_AccessorBody_block = Model.Name "block" + +_AccessorBody_expression = Model.Name "expression" + +_AccessorBody_empty = Model.Name "empty" + +-- | A single get or set accessor, with optional attributes and an access modifier. +data AccessorDeclaration = + AccessorDeclaration { + accessorDeclarationAttributes :: (Maybe Attributes), + accessorDeclarationModifier :: (Maybe AccessorModifier), + accessorDeclarationBody :: AccessorBody} + deriving (Eq, Ord, Read, Show) + +_AccessorDeclaration = Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration" + +_AccessorDeclaration_attributes = Model.Name "attributes" + +_AccessorDeclaration_modifier = Model.Name "modifier" + +_AccessorDeclaration_body = Model.Name "body" + +-- | The get and/or set accessors of a standard (non-ref-returning) property. +data AccessorDeclarations = + AccessorDeclarationsGet (Maybe AccessorDeclaration) | + AccessorDeclarationsSet (Maybe AccessorDeclaration) + deriving (Eq, Ord, Read, Show) + +_AccessorDeclarations = Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations" + +_AccessorDeclarations_get = Model.Name "get" + +_AccessorDeclarations_set = Model.Name "set" + +-- | An access modifier restricting a get or set accessor beyond the property's own accessibility. +data AccessorModifier = + AccessorModifierProtected | + AccessorModifierInternal | + AccessorModifierPrivate | + AccessorModifierProtectedInternal | + AccessorModifierInternalProtected | + AccessorModifierProtectedPrivate | + AccessorModifierPrivateProtected + deriving (Eq, Ord, Read, Show) + +_AccessorModifier = Model.Name "hydra.ext.csharp.syntax.AccessorModifier" + +_AccessorModifier_protected = Model.Name "protected" + +_AccessorModifier_internal = Model.Name "internal" + +_AccessorModifier_private = Model.Name "private" + +_AccessorModifier_protectedInternal = Model.Name "protectedInternal" + +_AccessorModifier_internalProtected = Model.Name "internalProtected" + +_AccessorModifier_protectedPrivate = Model.Name "protectedPrivate" + +_AccessorModifier_privateProtected = Model.Name "privateProtected" + +-- | An event declaration using explicit add/remove accessor syntax. +data AccessorsEventDeclaration = + AccessorsEventDeclaration { + accessorsEventDeclarationAttributes :: (Maybe Attributes), + accessorsEventDeclarationModifiers :: [EventModifier], + accessorsEventDeclarationType :: Type, + accessorsEventDeclarationName :: MemberName, + accessorsEventDeclarationAccessors :: EventAccessorDeclarations} + deriving (Eq, Ord, Read, Show) + +_AccessorsEventDeclaration = Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration" + +_AccessorsEventDeclaration_attributes = Model.Name "attributes" + +_AccessorsEventDeclaration_modifiers = Model.Name "modifiers" + +_AccessorsEventDeclaration_type = Model.Name "type" + +_AccessorsEventDeclaration_name = Model.Name "name" + +_AccessorsEventDeclaration_accessors = Model.Name "accessors" + +-- | The add or remove accessor body of an event declaration. +data AddRemoveAccessorDeclaration = + AddRemoveAccessorDeclaration { + addRemoveAccessorDeclarationAttributes :: (Maybe Attributes), + addRemoveAccessorDeclarationBody :: Block} + deriving (Eq, Ord, Read, Show) + +_AddRemoveAccessorDeclaration = Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration" + +_AddRemoveAccessorDeclaration_attributes = Model.Name "attributes" + +_AddRemoveAccessorDeclaration_body = Model.Name "body" + +-- | A simple multiplicative expression or a binary addition/subtraction expression. +data AdditiveExpression = + AdditiveExpressionSimple MultiplicativeExpression | + AdditiveExpressionBinary BinaryAdditiveExpression + deriving (Eq, Ord, Read, Show) + +_AdditiveExpression = Model.Name "hydra.ext.csharp.syntax.AdditiveExpression" + +_AdditiveExpression_simple = Model.Name "simple" + +_AdditiveExpression_binary = Model.Name "binary" + +-- | The plus or minus operator used in an additive expression. +data AdditiveOperator = + AdditiveOperatorPlus | + AdditiveOperatorMinus + deriving (Eq, Ord, Read, Show) + +_AdditiveOperator = Model.Name "hydra.ext.csharp.syntax.AdditiveOperator" + +_AdditiveOperator_plus = Model.Name "plus" + +_AdditiveOperator_minus = Model.Name "minus" + +-- | A simple equality expression or a binary bitwise-AND expression. +data AndExpression = + AndExpressionSimple EqualityExpression | + AndExpressionBinary BinaryAndExpression + deriving (Eq, Ord, Read, Show) + +_AndExpression = Model.Name "hydra.ext.csharp.syntax.AndExpression" + +_AndExpression_simple = Model.Name "simple" + +_AndExpression_binary = Model.Name "binary" + +-- | The body of an anonymous function: a null-conditional invocation, expression, ref, or block. +data AnonymousFunctionBody = + AnonymousFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression | + AnonymousFunctionBodyExpression Expression | + AnonymousFunctionBodyRef VariableReference | + AnonymousFunctionBodyBlock Block + deriving (Eq, Ord, Read, Show) + +_AnonymousFunctionBody = Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody" + +_AnonymousFunctionBody_nullConditionalInvocation = Model.Name "nullConditionalInvocation" + +_AnonymousFunctionBody_expression = Model.Name "expression" + +_AnonymousFunctionBody_ref = Model.Name "ref" + +_AnonymousFunctionBody_block = Model.Name "block" + +-- | A ref, out, or in modifier on an explicit anonymous function parameter. +data AnonymousFunctionParameterModifier = + AnonymousFunctionParameterModifierRef | + AnonymousFunctionParameterModifierOut | + AnonymousFunctionParameterModifierIn + deriving (Eq, Ord, Read, Show) + +_AnonymousFunctionParameterModifier = Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier" + +_AnonymousFunctionParameterModifier_ref = Model.Name "ref" + +_AnonymousFunctionParameterModifier_out = Model.Name "out" + +_AnonymousFunctionParameterModifier_in = Model.Name "in" + +-- | The parameter list of a lambda expression, either explicitly or implicitly typed. +data AnonymousFunctionSignature = + AnonymousFunctionSignatureExplicit [ExplicitAnonymousFunctionParameter] | + AnonymousFunctionSignatureImplicit [Identifier] + deriving (Eq, Ord, Read, Show) + +_AnonymousFunctionSignature = Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature" + +_AnonymousFunctionSignature_explicit = Model.Name "explicit" + +_AnonymousFunctionSignature_implicit = Model.Name "implicit" + +-- | A delegate expression created with the anonymous method syntax (delegate(...) { ... }). +data AnonymousMethodExpression = + AnonymousMethodExpression { + anonymousMethodExpressionAsync :: Bool, + anonymousMethodExpressionSignature :: [ExplicitAnonymousFunctionParameter], + anonymousMethodExpressionBody :: Block} + deriving (Eq, Ord, Read, Show) + +_AnonymousMethodExpression = Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression" + +_AnonymousMethodExpression_async = Model.Name "async" + +_AnonymousMethodExpression_signature = Model.Name "signature" + +_AnonymousMethodExpression_body = Model.Name "body" + +-- | A single argument in an argument list, with an optional name for named arguments. +data Argument = + Argument { + argumentName :: (Maybe Identifier), + argumentValue :: ArgumentValue} + deriving (Eq, Ord, Read, Show) + +_Argument = Model.Name "hydra.ext.csharp.syntax.Argument" + +_Argument_name = Model.Name "name" + +_Argument_value = Model.Name "value" + +-- | A non-empty, comma-separated list of arguments passed to a member or delegate invocation. +newtype ArgumentList = + ArgumentList { + unArgumentList :: [Argument]} + deriving (Eq, Ord, Read, Show) + +_ArgumentList = Model.Name "hydra.ext.csharp.syntax.ArgumentList" + +-- | The value portion of an argument: an expression, or a ref/in/out variable reference. +data ArgumentValue = + ArgumentValueExpression Expression | + ArgumentValueIn VariableReference | + ArgumentValueRef VariableReference | + ArgumentValueOut VariableReference + deriving (Eq, Ord, Read, Show) + +_ArgumentValue = Model.Name "hydra.ext.csharp.syntax.ArgumentValue" + +_ArgumentValue_expression = Model.Name "expression" + +_ArgumentValue_in = Model.Name "in" + +_ArgumentValue_ref = Model.Name "ref" + +_ArgumentValue_out = Model.Name "out" + +-- | An expression that creates a new array, in any of its three creation-syntax forms. +data ArrayCreationExpression = + ArrayCreationExpressionNonArrayType NonArrayTypeArrayCreationExpression | + ArrayCreationExpressionArrayType ArrayTypeArrayCreationExpression | + ArrayCreationExpressionRankSpecifier RankSpecifierArrayCreationExpression + deriving (Eq, Ord, Read, Show) + +_ArrayCreationExpression = Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression" + +_ArrayCreationExpression_nonArrayType = Model.Name "nonArrayType" + +_ArrayCreationExpression_arrayType = Model.Name "arrayType" + +_ArrayCreationExpression_rankSpecifier = Model.Name "rankSpecifier" + +-- | A brace-delimited list of variable initializers used to populate an array. +newtype ArrayInitializer = + ArrayInitializer { + unArrayInitializer :: [VariableInitializer]} + deriving (Eq, Ord, Read, Show) + +_ArrayInitializer = Model.Name "hydra.ext.csharp.syntax.ArrayInitializer" + +-- | An array type formed from a non-array element type and one or more rank specifiers. +data ArrayType = + ArrayType { + arrayTypeType :: NonArrayType, + arrayTypeRank :: [RankSpecifier]} + deriving (Eq, Ord, Read, Show) + +_ArrayType = Model.Name "hydra.ext.csharp.syntax.ArrayType" + +_ArrayType_type = Model.Name "type" + +_ArrayType_rank = Model.Name "rank" + +-- | Array creation using an explicit array type together with an array initializer. +data ArrayTypeArrayCreationExpression = + ArrayTypeArrayCreationExpression { + arrayTypeArrayCreationExpressionType :: ArrayType, + arrayTypeArrayCreationExpressionInitializer :: ArrayInitializer} + deriving (Eq, Ord, Read, Show) + +_ArrayTypeArrayCreationExpression = Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression" + +_ArrayTypeArrayCreationExpression_type = Model.Name "type" + +_ArrayTypeArrayCreationExpression_initializer = Model.Name "initializer" + +-- | An 'as' expression that attempts a type conversion, yielding null on failure. +data AsTypeExpression = + AsTypeExpression { + asTypeExpressionExpression :: RelationalExpression, + asTypeExpressionType :: Type} + deriving (Eq, Ord, Read, Show) + +_AsTypeExpression = Model.Name "hydra.ext.csharp.syntax.AsTypeExpression" + +_AsTypeExpression_expression = Model.Name "expression" + +_AsTypeExpression_type = Model.Name "type" + +-- | An assignment expression: a target, an assignment operator, and a right-hand expression. +data Assignment = + Assignment { + assignmentLeft :: UnaryExpression, + assignmentOperator :: AssignmentOperator, + assignmentRight :: Expression} + deriving (Eq, Ord, Read, Show) + +_Assignment = Model.Name "hydra.ext.csharp.syntax.Assignment" + +_Assignment_left = Model.Name "left" + +_Assignment_operator = Model.Name "operator" + +_Assignment_right = Model.Name "right" + +-- | A member declarator of the form 'name = expression' in an anonymous object creation. +data AssignmentMemberDeclarator = + AssignmentMemberDeclarator { + assignmentMemberDeclaratorIdentifier :: Identifier, + assignmentMemberDeclaratorExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_AssignmentMemberDeclarator = Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator" + +_AssignmentMemberDeclarator_identifier = Model.Name "identifier" + +_AssignmentMemberDeclarator_expression = Model.Name "expression" + +-- | The simple assignment operator or one of the compound assignment operators. +data AssignmentOperator = + AssignmentOperatorSimple Bool | + AssignmentOperatorPlusEquals | + AssignmentOperatorMinusEquals | + AssignmentOperatorTimesEquals | + AssignmentOperatorDivideEquals | + AssignmentOperatorModEquals | + AssignmentOperatorAndEquals | + AssignmentOperatorOrEquals | + AssignmentOperatorXorEquals | + AssignmentOperatorLeftShiftEquals | + AssignmentOperatorRightShiftEquals + deriving (Eq, Ord, Read, Show) + +_AssignmentOperator = Model.Name "hydra.ext.csharp.syntax.AssignmentOperator" + +_AssignmentOperator_simple = Model.Name "simple" + +_AssignmentOperator_plusEquals = Model.Name "plusEquals" + +_AssignmentOperator_minusEquals = Model.Name "minusEquals" + +_AssignmentOperator_timesEquals = Model.Name "timesEquals" + +_AssignmentOperator_divideEquals = Model.Name "divideEquals" + +_AssignmentOperator_modEquals = Model.Name "modEquals" + +_AssignmentOperator_andEquals = Model.Name "andEquals" + +_AssignmentOperator_orEquals = Model.Name "orEquals" + +_AssignmentOperator_xorEquals = Model.Name "xorEquals" + +_AssignmentOperator_leftShiftEquals = Model.Name "leftShiftEquals" + +_AssignmentOperator_rightShiftEquals = Model.Name "rightShiftEquals" + +-- | A single attribute, consisting of an attribute name and optional constructor/named arguments. +data Attribute = + Attribute { + attributeName :: AttributeName, + attributeArguments :: (Maybe AttributeArguments)} + deriving (Eq, Ord, Read, Show) + +_Attribute = Model.Name "hydra.ext.csharp.syntax.Attribute" + +_Attribute_name = Model.Name "name" + +_Attribute_arguments = Model.Name "arguments" + +-- | An expression usable as an attribute argument (a compile-time constant expression). +newtype AttributeArgumentExpression = + AttributeArgumentExpression { + unAttributeArgumentExpression :: NonAssignmentExpression} + deriving (Eq, Ord, Read, Show) + +_AttributeArgumentExpression = Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression" + +-- | The positional and named argument lists supplied to an attribute. +data AttributeArguments = + AttributeArguments { + attributeArgumentsPositonal :: (Maybe PositionalArgumentList), + attributeArgumentsNamed :: (Maybe NamedArgumentList)} + deriving (Eq, Ord, Read, Show) + +_AttributeArguments = Model.Name "hydra.ext.csharp.syntax.AttributeArguments" + +_AttributeArguments_positonal = Model.Name "positonal" + +_AttributeArguments_named = Model.Name "named" + +-- | A non-empty, comma-separated list of attributes within a single attribute section. +newtype AttributeList = + AttributeList { + unAttributeList :: [Attribute]} + deriving (Eq, Ord, Read, Show) + +_AttributeList = Model.Name "hydra.ext.csharp.syntax.AttributeList" + +-- | The type name referenced by an attribute, resolved against types ending in the suffix Attribute. +newtype AttributeName = + AttributeName { + unAttributeName :: TypeName} + deriving (Eq, Ord, Read, Show) + +_AttributeName = Model.Name "hydra.ext.csharp.syntax.AttributeName" + +-- | A bracketed attribute section, with an optional target specifier, attached to a declaration. +data AttributeSection = + AttributeSection { + attributeSectionTarget :: (Maybe AttributeTarget), + attributeSectionAttributes :: AttributeList} + deriving (Eq, Ord, Read, Show) + +_AttributeSection = Model.Name "hydra.ext.csharp.syntax.AttributeSection" + +_AttributeSection_target = Model.Name "target" + +_AttributeSection_attributes = Model.Name "attributes" + +-- | The target specifier of an attribute section (e.g. assembly, module, return, field). +data AttributeTarget = + AttributeTargetIdentifier Identifier | + AttributeTargetKeyword Keyword + deriving (Eq, Ord, Read, Show) + +_AttributeTarget = Model.Name "hydra.ext.csharp.syntax.AttributeTarget" + +_AttributeTarget_identifier = Model.Name "identifier" + +_AttributeTarget_keyword = Model.Name "keyword" + +-- | A non-empty sequence of attribute sections attached to a single declaration. +newtype Attributes = + Attributes { + unAttributes :: [AttributeSection]} + deriving (Eq, Ord, Read, Show) + +_Attributes = Model.Name "hydra.ext.csharp.syntax.Attributes" + +-- | A 'base' access expression, either invoking a base member or indexing via base[args]. +data BaseAccess = + BaseAccessIdentifier BaseAccessWithIdentifier | + BaseAccessArguments ArgumentList + deriving (Eq, Ord, Read, Show) + +_BaseAccess = Model.Name "hydra.ext.csharp.syntax.BaseAccess" + +_BaseAccess_identifier = Model.Name "identifier" + +_BaseAccess_arguments = Model.Name "arguments" + +-- | A 'base.member' access, with an optional list of type arguments. +data BaseAccessWithIdentifier = + BaseAccessWithIdentifier { + baseAccessWithIdentifierIdentifier :: Identifier, + baseAccessWithIdentifierTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_BaseAccessWithIdentifier = Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier" + +_BaseAccessWithIdentifier_identifier = Model.Name "identifier" + +_BaseAccessWithIdentifier_typeArguments = Model.Name "typeArguments" + +-- | A binary addition or subtraction expression with a left operand, operator, and right operand. +data BinaryAdditiveExpression = + BinaryAdditiveExpression { + binaryAdditiveExpressionLeft :: AdditiveExpression, + binaryAdditiveExpressionOperator :: AdditiveOperator, + binaryAdditiveExpressionRight :: MultiplicativeExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryAdditiveExpression = Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression" + +_BinaryAdditiveExpression_left = Model.Name "left" + +_BinaryAdditiveExpression_operator = Model.Name "operator" + +_BinaryAdditiveExpression_right = Model.Name "right" + +-- | A binary bitwise-AND expression (&) over two operand expressions. +data BinaryAndExpression = + BinaryAndExpression { + binaryAndExpressionLeft :: AndExpression, + binaryAndExpressionRight :: EqualityExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryAndExpression = Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression" + +_BinaryAndExpression_left = Model.Name "left" + +_BinaryAndExpression_right = Model.Name "right" + +-- | A binary conditional-AND expression (&&) over two operand expressions. +data BinaryConditionalAndExpression = + BinaryConditionalAndExpression { + binaryConditionalAndExpressionLeft :: ConditionalAndExpression, + binaryConditionalAndExpressionRight :: InclusiveOrExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryConditionalAndExpression = Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression" + +_BinaryConditionalAndExpression_left = Model.Name "left" + +_BinaryConditionalAndExpression_right = Model.Name "right" + +-- | A binary conditional-OR expression (||) over two operand expressions. +data BinaryConditionalOrExpression = + BinaryConditionalOrExpression { + binaryConditionalOrExpressionLeft :: ConditionalOrExpression, + binaryConditionalOrExpressionRight :: ConditionalAndExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryConditionalOrExpression = Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression" + +_BinaryConditionalOrExpression_left = Model.Name "left" + +_BinaryConditionalOrExpression_right = Model.Name "right" + +-- | A binary equality or inequality comparison expression. +data BinaryEqualityExpression = + BinaryEqualityExpression { + binaryEqualityExpressionLeft :: EqualityExpression, + binaryEqualityExpressionOperator :: EqualityOperator, + binaryEqualityExpressionRight :: RelationalExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryEqualityExpression = Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression" + +_BinaryEqualityExpression_left = Model.Name "left" + +_BinaryEqualityExpression_operator = Model.Name "operator" + +_BinaryEqualityExpression_right = Model.Name "right" + +-- | A binary bitwise exclusive-OR expression (^) over two operand expressions. +data BinaryExclusiveOrExpression = + BinaryExclusiveOrExpression { + binaryExclusiveOrExpressionLeft :: ExclusiveOrExpression, + binaryExclusiveOrExpressionRight :: AndExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryExclusiveOrExpression = Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression" + +_BinaryExclusiveOrExpression_left = Model.Name "left" + +_BinaryExclusiveOrExpression_right = Model.Name "right" + +-- | A binary bitwise inclusive-OR expression (|) over two operand expressions. +data BinaryInclusiveOrExpression = + BinaryInclusiveOrExpression { + binaryInclusiveOrExpressionLeft :: InclusiveOrExpression, + binaryInclusiveOrExpressionRight :: ExclusiveOrExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryInclusiveOrExpression = Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression" + +_BinaryInclusiveOrExpression_left = Model.Name "left" + +_BinaryInclusiveOrExpression_right = Model.Name "right" + +-- | A binary multiplication, division, or remainder expression. +data BinaryMultiplicativeExpression = + BinaryMultiplicativeExpression { + binaryMultiplicativeExpressionLeft :: MultiplicativeExpression, + binaryMultiplicativeExpressionOperator :: MultiplicativeOperator, + binaryMultiplicativeExpressionRight :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryMultiplicativeExpression = Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression" + +_BinaryMultiplicativeExpression_left = Model.Name "left" + +_BinaryMultiplicativeExpression_operator = Model.Name "operator" + +_BinaryMultiplicativeExpression_right = Model.Name "right" + +-- | A binary null-coalescing expression (??) over two operand expressions. +data BinaryNullCoalescingExpression = + BinaryNullCoalescingExpression { + binaryNullCoalescingExpressionLeft :: ConditionalOrExpression, + binaryNullCoalescingExpressionRight :: NullCoalescingExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryNullCoalescingExpression = Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression" + +_BinaryNullCoalescingExpression_left = Model.Name "left" + +_BinaryNullCoalescingExpression_right = Model.Name "right" + +-- | The declarator for a user-defined binary operator overload, naming its two parameters. +data BinaryOperatorDeclarator = + BinaryOperatorDeclarator { + binaryOperatorDeclaratorType :: Type, + binaryOperatorDeclaratorOperator :: OverloadableBinaryOperator, + binaryOperatorDeclaratorLeft :: FixedParameter, + binaryOperatorDeclaratorRight :: FixedParameter} + deriving (Eq, Ord, Read, Show) + +_BinaryOperatorDeclarator = Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator" + +_BinaryOperatorDeclarator_type = Model.Name "type" + +_BinaryOperatorDeclarator_operator = Model.Name "operator" + +_BinaryOperatorDeclarator_left = Model.Name "left" + +_BinaryOperatorDeclarator_right = Model.Name "right" + +-- | A binary relational comparison expression (<, >, <=, or >=). +data BinaryRelationalExpression = + BinaryRelationalExpression { + binaryRelationalExpressionLeft :: RelationalExpression, + binaryRelationalExpressionOperator :: RelationalOperator, + binaryRelationalExpressionRight :: ShiftExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryRelationalExpression = Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression" + +_BinaryRelationalExpression_left = Model.Name "left" + +_BinaryRelationalExpression_operator = Model.Name "operator" + +_BinaryRelationalExpression_right = Model.Name "right" + +-- | A binary left-shift or right-shift expression. +data BinaryShiftExpression = + BinaryShiftExpression { + binaryShiftExpressionLeft :: ShiftExpression, + binaryShiftExpressionOperator :: ShiftOperator, + binaryShiftExpressionRight :: AdditiveExpression} + deriving (Eq, Ord, Read, Show) + +_BinaryShiftExpression = Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression" + +_BinaryShiftExpression_left = Model.Name "left" + +_BinaryShiftExpression_operator = Model.Name "operator" + +_BinaryShiftExpression_right = Model.Name "right" + +-- | A brace-delimited sequence of statements forming a single compound statement. +newtype Block = + Block { + unBlock :: [Statement]} + deriving (Eq, Ord, Read, Show) + +_Block = Model.Name "hydra.ext.csharp.syntax.Block" + +-- | A property body given as get/set accessor declarations, with an optional initializer. +data BlockPropertyBody = + BlockPropertyBody { + blockPropertyBodyAccessors :: AccessorDeclarations, + blockPropertyBodyInitializer :: (Maybe VariableInitializer)} + deriving (Eq, Ord, Read, Show) + +_BlockPropertyBody = Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody" + +_BlockPropertyBody_accessors = Model.Name "accessors" + +_BlockPropertyBody_initializer = Model.Name "initializer" + +-- | An expression required to have (or be convertible to) type bool, such as an if condition. +newtype BooleanExpression = + BooleanExpression { + unBooleanExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_BooleanExpression = Model.Name "hydra.ext.csharp.syntax.BooleanExpression" + +-- | An explicit type-cast expression applied to a unary expression. +data CastExpression = + CastExpression { + castExpressionType :: Type, + castExpressionExpression :: UnaryExpression} + deriving (Eq, Ord, Read, Show) + +_CastExpression = Model.Name "hydra.ext.csharp.syntax.CastExpression" + +_CastExpression_type = Model.Name "type" + +_CastExpression_expression = Model.Name "expression" + +-- | The catch clauses of a try statement: one or more specific clauses, or a single general clause. +data CatchClauses = + CatchClausesSpecific [SpecificCatchClause] | + CatchClausesGeneral Block + deriving (Eq, Ord, Read, Show) + +_CatchClauses = Model.Name "hydra.ext.csharp.syntax.CatchClauses" + +_CatchClauses_specific = Model.Name "specific" + +_CatchClauses_general = Model.Name "general" + +-- | The base class and/or implemented interfaces listed in a class declaration's base-list. +data ClassBase = + ClassBaseClass (Maybe ClassType) | + ClassBaseInterfaces [InterfaceType] + deriving (Eq, Ord, Read, Show) + +_ClassBase = Model.Name "hydra.ext.csharp.syntax.ClassBase" + +_ClassBase_class = Model.Name "class" + +_ClassBase_interfaces = Model.Name "interfaces" + +-- | The brace-delimited sequence of member declarations that make up a class. +newtype ClassBody = + ClassBody { + unClassBody :: [ClassMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_ClassBody = Model.Name "hydra.ext.csharp.syntax.ClassBody" + +-- | A C# class declaration, including its modifiers, type parameters, base list, and body. +data ClassDeclaration = + ClassDeclaration { + classDeclarationAttributes :: [AttributeSection], + classDeclarationModifiers :: [ClassModifier], + classDeclarationPartial :: Bool, + classDeclarationName :: Identifier, + classDeclarationParameters :: (Maybe TypeParameterList), + classDeclarationBase :: (Maybe ClassBase), + classDeclarationConstraints :: [TypeParameterConstraintsClause], + classDeclarationBody :: ClassBody} + deriving (Eq, Ord, Read, Show) + +_ClassDeclaration = Model.Name "hydra.ext.csharp.syntax.ClassDeclaration" + +_ClassDeclaration_attributes = Model.Name "attributes" + +_ClassDeclaration_modifiers = Model.Name "modifiers" + +_ClassDeclaration_partial = Model.Name "partial" + +_ClassDeclaration_name = Model.Name "name" + +_ClassDeclaration_parameters = Model.Name "parameters" + +_ClassDeclaration_base = Model.Name "base" + +_ClassDeclaration_constraints = Model.Name "constraints" + +_ClassDeclaration_body = Model.Name "body" + +-- | Any member that can appear in a class body: field, method, property, event, and so on. +data ClassMemberDeclaration = + ClassMemberDeclarationConstant ConstantDeclaration | + ClassMemberDeclarationField FieldDeclaration | + ClassMemberDeclarationMethod MethodDeclaration | + ClassMemberDeclarationProperty PropertyDeclaration | + ClassMemberDeclarationEvent EventDeclaration | + ClassMemberDeclarationIndexer IndexerDeclaration | + ClassMemberDeclarationOperator OperatorDeclaration | + ClassMemberDeclarationConstructor ConstructorDeclaration | + ClassMemberDeclarationFinalizer FinalizerDeclaration | + ClassMemberDeclarationStaticConstructor StaticConstructorDeclaration | + ClassMemberDeclarationType TypeDeclaration + deriving (Eq, Ord, Read, Show) + +_ClassMemberDeclaration = Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration" + +_ClassMemberDeclaration_constant = Model.Name "constant" + +_ClassMemberDeclaration_field = Model.Name "field" + +_ClassMemberDeclaration_method = Model.Name "method" + +_ClassMemberDeclaration_property = Model.Name "property" + +_ClassMemberDeclaration_event = Model.Name "event" + +_ClassMemberDeclaration_indexer = Model.Name "indexer" + +_ClassMemberDeclaration_operator = Model.Name "operator" + +_ClassMemberDeclaration_constructor = Model.Name "constructor" + +_ClassMemberDeclaration_finalizer = Model.Name "finalizer" + +_ClassMemberDeclaration_staticConstructor = Model.Name "staticConstructor" + +_ClassMemberDeclaration_type = Model.Name "type" + +-- | A modifier keyword on a class declaration, such as public, abstract, sealed, or static. +data ClassModifier = + ClassModifierNew | + ClassModifierPublic | + ClassModifierProtected | + ClassModifierInternal | + ClassModifierPrivate | + ClassModifierAbstract | + ClassModifierSealed | + ClassModifierStatic | + ClassModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_ClassModifier = Model.Name "hydra.ext.csharp.syntax.ClassModifier" + +_ClassModifier_new = Model.Name "new" + +_ClassModifier_public = Model.Name "public" + +_ClassModifier_protected = Model.Name "protected" + +_ClassModifier_internal = Model.Name "internal" + +_ClassModifier_private = Model.Name "private" + +_ClassModifier_abstract = Model.Name "abstract" + +_ClassModifier_sealed = Model.Name "sealed" + +_ClassModifier_static = Model.Name "static" + +_ClassModifier_unsafe = Model.Name "unsafe" + +-- | A reference to a class type: a named type, or the predefined 'object' or 'string' types. +data ClassType = + ClassTypeTypeName TypeName | + ClassTypeObject | + ClassTypeString + deriving (Eq, Ord, Read, Show) + +_ClassType = Model.Name "hydra.ext.csharp.syntax.ClassType" + +_ClassType_typeName = Model.Name "typeName" + +_ClassType_object = Model.Name "object" + +_ClassType_string = Model.Name "string" + +-- | The root of a C# source file: extern aliases, using directives, attributes, and type members. +data CompilationUnit = + CompilationUnit { + compilationUnitExterns :: [ExternAliasDirective], + compilationUnitUsings :: [UsingDirective], + compilationUnitAttributes :: [GlobalAttributeSection], + compilationUnitMembers :: [NamespaceMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_CompilationUnit = Model.Name "hydra.ext.csharp.syntax.CompilationUnit" + +_CompilationUnit_externs = Model.Name "externs" + +_CompilationUnit_usings = Model.Name "usings" + +_CompilationUnit_attributes = Model.Name "attributes" + +_CompilationUnit_members = Model.Name "members" + +-- | A simple inclusive-OR expression or a binary conditional-AND (&&) expression. +data ConditionalAndExpression = + ConditionalAndExpressionSimple InclusiveOrExpression | + ConditionalAndExpressionBinary BinaryConditionalAndExpression + deriving (Eq, Ord, Read, Show) + +_ConditionalAndExpression = Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression" + +_ConditionalAndExpression_simple = Model.Name "simple" + +_ConditionalAndExpression_binary = Model.Name "binary" + +-- | The ternary conditional expression, in its simple, ref-conditional, or fallthrough forms. +data ConditionalExpression = + ConditionalExpressionSimple NullCoalescingExpression | + ConditionalExpressionSimpleConditional SimpleConditionalExpression | + ConditionalExpressionRefConditional RefConditionalExpression + deriving (Eq, Ord, Read, Show) + +_ConditionalExpression = Model.Name "hydra.ext.csharp.syntax.ConditionalExpression" + +_ConditionalExpression_simple = Model.Name "simple" + +_ConditionalExpression_simpleConditional = Model.Name "simpleConditional" + +_ConditionalExpression_refConditional = Model.Name "refConditional" + +-- | A simple conditional-AND expression or a binary conditional-OR (||) expression. +data ConditionalOrExpression = + ConditionalOrExpressionSimple ConditionalAndExpression | + ConditionalOrExpressionBinary BinaryConditionalOrExpression + deriving (Eq, Ord, Read, Show) + +_ConditionalOrExpression = Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression" + +_ConditionalOrExpression_simple = Model.Name "simple" + +_ConditionalOrExpression_binary = Model.Name "binary" + +-- | A 'const' field declaration with its modifiers, type, and one or more declarators. +data ConstantDeclaration = + ConstantDeclaration { + constantDeclarationAttributes :: (Maybe Attributes), + constantDeclarationModifiers :: [ConstantModifier], + constantDeclarationType :: Type, + constantDeclarationDeclarators :: [ConstantDeclarator]} + deriving (Eq, Ord, Read, Show) + +_ConstantDeclaration = Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration" + +_ConstantDeclaration_attributes = Model.Name "attributes" + +_ConstantDeclaration_modifiers = Model.Name "modifiers" + +_ConstantDeclaration_type = Model.Name "type" + +_ConstantDeclaration_declarators = Model.Name "declarators" + +-- | A single 'identifier = expression' pair within a constant declaration. +data ConstantDeclarator = + ConstantDeclarator { + constantDeclaratorIdentifier :: Identifier, + constantDeclaratorExpression :: ConstantExpression} + deriving (Eq, Ord, Read, Show) + +_ConstantDeclarator = Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator" + +_ConstantDeclarator_identifier = Model.Name "identifier" + +_ConstantDeclarator_expression = Model.Name "expression" + +-- | An expression that is required to be evaluable at compile time. +newtype ConstantExpression = + ConstantExpression { + unConstantExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_ConstantExpression = Model.Name "hydra.ext.csharp.syntax.ConstantExpression" + +-- | An access modifier (new, public, protected, internal, or private) on a constant declaration. +data ConstantModifier = + ConstantModifierNew | + ConstantModifierPublic | + ConstantModifierProtected | + ConstantModifierInternal | + ConstantModifierPrivate + deriving (Eq, Ord, Read, Show) + +_ConstantModifier = Model.Name "hydra.ext.csharp.syntax.ConstantModifier" + +_ConstantModifier_new = Model.Name "new" + +_ConstantModifier_public = Model.Name "public" + +_ConstantModifier_protected = Model.Name "protected" + +_ConstantModifier_internal = Model.Name "internal" + +_ConstantModifier_private = Model.Name "private" + +-- | The body of an instance constructor: a block, expression body, or empty (extern) body. +data ConstructorBody = + ConstructorBodyBlock Block | + ConstructorBodyExpression Expression | + ConstructorBodyEmpty + deriving (Eq, Ord, Read, Show) + +_ConstructorBody = Model.Name "hydra.ext.csharp.syntax.ConstructorBody" + +_ConstructorBody_block = Model.Name "block" + +_ConstructorBody_expression = Model.Name "expression" + +_ConstructorBody_empty = Model.Name "empty" + +-- | An instance constructor declaration, including its declarator and body. +data ConstructorDeclaration = + ConstructorDeclaration { + constructorDeclarationAttributes :: (Maybe Attributes), + constructorDeclarationModifiers :: [ConstructorModifier], + constructorDeclarationDeclarator :: ConstructorDeclarator, + constructorDeclarationBody :: ConstructorBody} + deriving (Eq, Ord, Read, Show) + +_ConstructorDeclaration = Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration" + +_ConstructorDeclaration_attributes = Model.Name "attributes" + +_ConstructorDeclaration_modifiers = Model.Name "modifiers" + +_ConstructorDeclaration_declarator = Model.Name "declarator" + +_ConstructorDeclaration_body = Model.Name "body" + +-- | A constructor's name, parameter list, and optional base/this initializer. +data ConstructorDeclarator = + ConstructorDeclarator { + constructorDeclaratorName :: Identifier, + constructorDeclaratorParameters :: (Maybe FormalParameterList), + constructorDeclaratorInitializer :: (Maybe ConstructorInitializer)} + deriving (Eq, Ord, Read, Show) + +_ConstructorDeclarator = Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator" + +_ConstructorDeclarator_name = Model.Name "name" + +_ConstructorDeclarator_parameters = Model.Name "parameters" + +_ConstructorDeclarator_initializer = Model.Name "initializer" + +-- | A ': base(...)' or ': this(...)' initializer invoked before a constructor body runs. +data ConstructorInitializer = + ConstructorInitializerBase (Maybe ArgumentList) | + ConstructorInitializerThis (Maybe ArgumentList) + deriving (Eq, Ord, Read, Show) + +_ConstructorInitializer = Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer" + +_ConstructorInitializer_base = Model.Name "base" + +_ConstructorInitializer_this = Model.Name "this" + +-- | An access or extern/unsafe modifier on an instance constructor declaration. +data ConstructorModifier = + ConstructorModifierPublic | + ConstructorModifierProtected | + ConstructorModifierInternal | + ConstructorModifierPrivate | + ConstructorModifierExtern | + ConstructorModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_ConstructorModifier = Model.Name "hydra.ext.csharp.syntax.ConstructorModifier" + +_ConstructorModifier_public = Model.Name "public" + +_ConstructorModifier_protected = Model.Name "protected" + +_ConstructorModifier_internal = Model.Name "internal" + +_ConstructorModifier_private = Model.Name "private" + +_ConstructorModifier_extern = Model.Name "extern" + +_ConstructorModifier_unsafe = Model.Name "unsafe" + +-- | Whether a user-defined conversion operator is implicit or explicit. +data ConversionKind = + ConversionKindImplicit | + ConversionKindExplicit + deriving (Eq, Ord, Read, Show) + +_ConversionKind = Model.Name "hydra.ext.csharp.syntax.ConversionKind" + +_ConversionKind_implicit = Model.Name "implicit" + +_ConversionKind_explicit = Model.Name "explicit" + +-- | The declarator for a user-defined implicit or explicit conversion operator. +data ConversionOperatorDeclarator = + ConversionOperatorDeclarator { + conversionOperatorDeclaratorKind :: ConversionKind, + conversionOperatorDeclaratorType :: Type, + conversionOperatorDeclaratorParameter :: FixedParameter} + deriving (Eq, Ord, Read, Show) + +_ConversionOperatorDeclarator = Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator" + +_ConversionOperatorDeclarator_kind = Model.Name "kind" + +_ConversionOperatorDeclarator_type = Model.Name "type" + +_ConversionOperatorDeclarator_parameter = Model.Name "parameter" + +-- | An inline variable declaration used as an expression, such as an out-variable declaration. +data DeclarationExpression = + DeclarationExpression { + declarationExpressionType :: LocalVariableType, + declarationExpressionIdentifier :: Identifier} + deriving (Eq, Ord, Read, Show) + +_DeclarationExpression = Model.Name "hydra.ext.csharp.syntax.DeclarationExpression" + +_DeclarationExpression_type = Model.Name "type" + +_DeclarationExpression_identifier = Model.Name "identifier" + +-- | A pattern that tests an expression's type and, on success, binds it to a designation. +data DeclarationPattern = + DeclarationPattern { + declarationPatternType :: Type, + declarationPatternDesignation :: Designation} + deriving (Eq, Ord, Read, Show) + +_DeclarationPattern = Model.Name "hydra.ext.csharp.syntax.DeclarationPattern" + +_DeclarationPattern_type = Model.Name "type" + +_DeclarationPattern_designation = Model.Name "designation" + +-- | A local variable, local constant, or local function declaration statement. +data DeclarationStatement = + DeclarationStatementVariable LocalVariableDeclaration | + DeclarationStatementConstant LocalConstantDeclaration | + DeclarationStatementFunction LocalFunctionDeclaration + deriving (Eq, Ord, Read, Show) + +_DeclarationStatement = Model.Name "hydra.ext.csharp.syntax.DeclarationStatement" + +_DeclarationStatement_variable = Model.Name "variable" + +_DeclarationStatement_constant = Model.Name "constant" + +_DeclarationStatement_function = Model.Name "function" + +-- | One element of a deconstruction pattern: a nested tuple or a bound identifier. +data DeconstructionElement = + DeconstructionElementTuple DeconstructionTuple | + DeconstructionElementIdentifier Identifier + deriving (Eq, Ord, Read, Show) + +_DeconstructionElement = Model.Name "hydra.ext.csharp.syntax.DeconstructionElement" + +_DeconstructionElement_tuple = Model.Name "tuple" + +_DeconstructionElement_identifier = Model.Name "identifier" + +-- | A tuple deconstruction pattern used on the left-hand side of a deconstructing assignment. +newtype DeconstructionTuple = + DeconstructionTuple { + unDeconstructionTuple :: [DeconstructionElement]} + deriving (Eq, Ord, Read, Show) + +_DeconstructionTuple = Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple" + +-- | A 'default(T)' expression, or the type-inferred 'default' literal. +data DefaultValueExpression = + DefaultValueExpressionExplicitlyTyped Type | + DefaultValueExpressionDefaultLiteral + deriving (Eq, Ord, Read, Show) + +_DefaultValueExpression = Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression" + +_DefaultValueExpression_explicitlyTyped = Model.Name "explicitlyTyped" + +_DefaultValueExpression_defaultLiteral = Model.Name "defaultLiteral" + +-- | An expression that creates a delegate instance from a method group or lambda. +data DelegateCreationExpression = + DelegateCreationExpression { + delegateCreationExpressionType :: DelegateType, + delegateCreationExpressionExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_DelegateCreationExpression = Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression" + +_DelegateCreationExpression_type = Model.Name "type" + +_DelegateCreationExpression_expression = Model.Name "expression" + +-- | A delegate type declaration, naming its return type, ref kind, and parameter list. +data DelegateDeclaration = + DelegateDeclaration { + delegateDeclarationAttributes :: (Maybe Attributes), + delegateDeclarationModifiers :: [DelegateModifier], + delegateDeclarationReturnType :: ReturnType, + delegateDeclarationRefKind :: (Maybe RefKind), + delegateDeclarationRefReturnType :: (Maybe Type), + delegateDeclarationHeader :: DelegateHeader} + deriving (Eq, Ord, Read, Show) + +_DelegateDeclaration = Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration" + +_DelegateDeclaration_attributes = Model.Name "attributes" + +_DelegateDeclaration_modifiers = Model.Name "modifiers" + +_DelegateDeclaration_returnType = Model.Name "returnType" + +_DelegateDeclaration_refKind = Model.Name "refKind" + +_DelegateDeclaration_refReturnType = Model.Name "refReturnType" + +_DelegateDeclaration_header = Model.Name "header" + +-- | The name, type parameters, formal parameters, and constraints of a delegate declaration. +data DelegateHeader = + DelegateHeader { + delegateHeaderName :: Identifier, + delegateHeaderTypeParameters :: (Maybe VariantTypeParameters), + delegateHeaderParameters :: (Maybe FormalParameterList), + delegateHeaderConstraints :: [TypeParameterConstraintsClause]} + deriving (Eq, Ord, Read, Show) + +_DelegateHeader = Model.Name "hydra.ext.csharp.syntax.DelegateHeader" + +_DelegateHeader_name = Model.Name "name" + +_DelegateHeader_typeParameters = Model.Name "typeParameters" + +_DelegateHeader_parameters = Model.Name "parameters" + +_DelegateHeader_constraints = Model.Name "constraints" + +-- | An access or unsafe modifier on a delegate type declaration. +data DelegateModifier = + DelegateModifierNew | + DelegateModifierPublic | + DelegateModifierProtected | + DelegateModifierInternal | + DelegateModifierPrivate | + DelegateModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_DelegateModifier = Model.Name "hydra.ext.csharp.syntax.DelegateModifier" + +_DelegateModifier_new = Model.Name "new" + +_DelegateModifier_public = Model.Name "public" + +_DelegateModifier_protected = Model.Name "protected" + +_DelegateModifier_internal = Model.Name "internal" + +_DelegateModifier_private = Model.Name "private" + +_DelegateModifier_unsafe = Model.Name "unsafe" + +-- | A reference to a delegate type by its type name. +newtype DelegateType = + DelegateType { + unDelegateType :: TypeName} + deriving (Eq, Ord, Read, Show) + +_DelegateType = Model.Name "hydra.ext.csharp.syntax.DelegateType" + +-- | A member access, element access, or invocation chained after a null-conditional operator. +data DependentAccess = + DependentAccessMemberAccess DependentAccessForMember | + DependentAccessElementAccess ArgumentList | + DependentAccessInvocation (Maybe ArgumentList) + deriving (Eq, Ord, Read, Show) + +_DependentAccess = Model.Name "hydra.ext.csharp.syntax.DependentAccess" + +_DependentAccess_memberAccess = Model.Name "memberAccess" + +_DependentAccess_elementAccess = Model.Name "elementAccess" + +_DependentAccess_invocation = Model.Name "invocation" + +-- | A member identifier and optional type arguments chained after a null-conditional access. +data DependentAccessForMember = + DependentAccessForMember { + dependentAccessForMemberIdentifier :: Identifier, + dependentAccessForMemberTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_DependentAccessForMember = Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember" + +_DependentAccessForMember_identifier = Model.Name "identifier" + +_DependentAccessForMember_typeArguments = Model.Name "typeArguments" + +-- | A simple identifier binding introduced by a pattern, such as in a declaration pattern. +newtype Designation = + Designation { + unDesignation :: Identifier} + deriving (Eq, Ord, Read, Show) + +_Designation = Model.Name "hydra.ext.csharp.syntax.Designation" + +-- | A do-while iteration statement that executes its body at least once. +data DoStatement = + DoStatement { + doStatementBody :: EmbeddedStatement, + doStatementWhile :: BooleanExpression} + deriving (Eq, Ord, Read, Show) + +_DoStatement = Model.Name "hydra.ext.csharp.syntax.DoStatement" + +_DoStatement_body = Model.Name "body" + +_DoStatement_while = Model.Name "while" + +-- | An indexer access expression applying an argument list to a primary expression. +data ElementAccess = + ElementAccess { + elementAccessExpression :: PrimaryNoArrayCreationExpression, + elementAccessArguments :: ArgumentList} + deriving (Eq, Ord, Read, Show) + +_ElementAccess = Model.Name "hydra.ext.csharp.syntax.ElementAccess" + +_ElementAccess_expression = Model.Name "expression" + +_ElementAccess_arguments = Model.Name "arguments" + +-- | A single element of a collection initializer: one expression, or a nested element list. +data ElementInitializer = + ElementInitializerSingle NonAssignmentExpression | + ElementInitializerList ExpressionList + deriving (Eq, Ord, Read, Show) + +_ElementInitializer = Model.Name "hydra.ext.csharp.syntax.ElementInitializer" + +_ElementInitializer_single = Model.Name "single" + +_ElementInitializer_list = Model.Name "list" + +-- | A statement nested inside another statement, excluding labeled and declaration statements. +data EmbeddedStatement = + EmbeddedStatementBlock Block | + EmbeddedStatementEmpty | + EmbeddedStatementExpression StatementExpression | + EmbeddedStatementSelection SelectionStatement | + EmbeddedStatementIteration IterationStatement | + EmbeddedStatementJump JumpStatement | + EmbeddedStatementTry TryStatement | + EmbeddedStatementChecked Block | + EmbeddedStatementUnchecked Block | + EmbeddedStatementLock LockStatement | + EmbeddedStatementUsing UsingStatement | + EmbeddedStatementYield YieldStatement | + EmbeddedStatementUnsafe Block | + EmbeddedStatementFixed FixedStatement + deriving (Eq, Ord, Read, Show) + +_EmbeddedStatement = Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement" + +_EmbeddedStatement_block = Model.Name "block" + +_EmbeddedStatement_empty = Model.Name "empty" + +_EmbeddedStatement_expression = Model.Name "expression" + +_EmbeddedStatement_selection = Model.Name "selection" + +_EmbeddedStatement_iteration = Model.Name "iteration" + +_EmbeddedStatement_jump = Model.Name "jump" + +_EmbeddedStatement_try = Model.Name "try" + +_EmbeddedStatement_checked = Model.Name "checked" + +_EmbeddedStatement_unchecked = Model.Name "unchecked" + +_EmbeddedStatement_lock = Model.Name "lock" + +_EmbeddedStatement_using = Model.Name "using" + +_EmbeddedStatement_yield = Model.Name "yield" + +_EmbeddedStatement_unsafe = Model.Name "unsafe" + +_EmbeddedStatement_fixed = Model.Name "fixed" + +-- | The optional explicit underlying integral type declared for an enum. +data EnumBase = + EnumBaseType IntegralType | + EnumBaseName TypeName + deriving (Eq, Ord, Read, Show) + +_EnumBase = Model.Name "hydra.ext.csharp.syntax.EnumBase" + +_EnumBase_type = Model.Name "type" + +_EnumBase_name = Model.Name "name" + +-- | The brace-delimited list of member declarations that make up an enum. +newtype EnumBody = + EnumBody { + unEnumBody :: [EnumMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_EnumBody = Model.Name "hydra.ext.csharp.syntax.EnumBody" + +-- | An enum type declaration, with its modifiers, name, underlying type, and members. +data EnumDeclaration = + EnumDeclaration { + enumDeclarationAttributes :: (Maybe Attributes), + enumDeclarationModifiers :: [EnumModifier], + enumDeclarationName :: Identifier, + enumDeclarationBase :: (Maybe EnumBase), + enumDeclarationBody :: (Maybe EnumBody)} + deriving (Eq, Ord, Read, Show) + +_EnumDeclaration = Model.Name "hydra.ext.csharp.syntax.EnumDeclaration" + +_EnumDeclaration_attributes = Model.Name "attributes" + +_EnumDeclaration_modifiers = Model.Name "modifiers" + +_EnumDeclaration_name = Model.Name "name" + +_EnumDeclaration_base = Model.Name "base" + +_EnumDeclaration_body = Model.Name "body" + +-- | A single named enum member, with optional attributes and an explicit constant value. +data EnumMemberDeclaration = + EnumMemberDeclaration { + enumMemberDeclarationAttributes :: (Maybe Attributes), + enumMemberDeclarationName :: Identifier, + enumMemberDeclarationValue :: (Maybe ConstantExpression)} + deriving (Eq, Ord, Read, Show) + +_EnumMemberDeclaration = Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration" + +_EnumMemberDeclaration_attributes = Model.Name "attributes" + +_EnumMemberDeclaration_name = Model.Name "name" + +_EnumMemberDeclaration_value = Model.Name "value" + +-- | An access modifier (new, public, protected, internal, or private) on an enum declaration. +data EnumModifier = + EnumModifierNew | + EnumModifierPublic | + EnumModifierProtected | + EnumModifierInternal | + EnumModifierPrivate + deriving (Eq, Ord, Read, Show) + +_EnumModifier = Model.Name "hydra.ext.csharp.syntax.EnumModifier" + +_EnumModifier_new = Model.Name "new" + +_EnumModifier_public = Model.Name "public" + +_EnumModifier_protected = Model.Name "protected" + +_EnumModifier_internal = Model.Name "internal" + +_EnumModifier_private = Model.Name "private" + +-- | A reference to an enum type by its type name. +newtype EnumType = + EnumType { + unEnumType :: TypeName} + deriving (Eq, Ord, Read, Show) + +_EnumType = Model.Name "hydra.ext.csharp.syntax.EnumType" + +-- | A simple relational expression or a binary equality/inequality expression. +data EqualityExpression = + EqualityExpressionSimple RelationalExpression | + EqualityExpressionBinary BinaryEqualityExpression + deriving (Eq, Ord, Read, Show) + +_EqualityExpression = Model.Name "hydra.ext.csharp.syntax.EqualityExpression" + +_EqualityExpression_simple = Model.Name "simple" + +_EqualityExpression_binary = Model.Name "binary" + +-- | The equality (==) or inequality (!=) operator. +data EqualityOperator = + EqualityOperatorEqual | + EqualityOperatorNotEqual + deriving (Eq, Ord, Read, Show) + +_EqualityOperator = Model.Name "hydra.ext.csharp.syntax.EqualityOperator" + +_EqualityOperator_equal = Model.Name "equal" + +_EqualityOperator_notEqual = Model.Name "notEqual" + +-- | The add and remove accessor declarations of an event with an explicit accessor body. +data EventAccessorDeclarations = + EventAccessorDeclarationsAdd AddRemoveAccessorDeclaration | + EventAccessorDeclarationsRemove AddRemoveAccessorDeclaration + deriving (Eq, Ord, Read, Show) + +_EventAccessorDeclarations = Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations" + +_EventAccessorDeclarations_add = Model.Name "add" + +_EventAccessorDeclarations_remove = Model.Name "remove" + +-- | An event member declaration, in either its field-like or explicit-accessor form. +data EventDeclaration = + EventDeclarationStandard StandardEventDeclaration | + EventDeclarationAccessors AccessorsEventDeclaration + deriving (Eq, Ord, Read, Show) + +_EventDeclaration = Model.Name "hydra.ext.csharp.syntax.EventDeclaration" + +_EventDeclaration_standard = Model.Name "standard" + +_EventDeclaration_accessors = Model.Name "accessors" + +-- | A modifier keyword on an event declaration, such as static, virtual, or override. +data EventModifier = + EventModifierNew | + EventModifierPublic | + EventModifierProtected | + EventModifierInternal | + EventModifierPrivate | + EventModifierStatic | + EventModifierVirtual | + EventModifierSealed | + EventModifierOverride | + EventModifierAbstract | + EventModifierExtern | + EventModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_EventModifier = Model.Name "hydra.ext.csharp.syntax.EventModifier" + +_EventModifier_new = Model.Name "new" + +_EventModifier_public = Model.Name "public" + +_EventModifier_protected = Model.Name "protected" + +_EventModifier_internal = Model.Name "internal" + +_EventModifier_private = Model.Name "private" + +_EventModifier_static = Model.Name "static" + +_EventModifier_virtual = Model.Name "virtual" + +_EventModifier_sealed = Model.Name "sealed" + +_EventModifier_override = Model.Name "override" + +_EventModifier_abstract = Model.Name "abstract" + +_EventModifier_extern = Model.Name "extern" + +_EventModifier_unsafe = Model.Name "unsafe" + +-- | The exception type and optional identifier caught by a specific catch clause. +data ExceptionSpecifier = + ExceptionSpecifier { + exceptionSpecifierType :: Type, + exceptionSpecifierIdentifier :: (Maybe Identifier)} + deriving (Eq, Ord, Read, Show) + +_ExceptionSpecifier = Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier" + +_ExceptionSpecifier_type = Model.Name "type" + +_ExceptionSpecifier_identifier = Model.Name "identifier" + +-- | A simple AND expression or a binary bitwise exclusive-OR (^) expression. +data ExclusiveOrExpression = + ExclusiveOrExpressionSimple AndExpression | + ExclusiveOrExpressionBinary BinaryExclusiveOrExpression + deriving (Eq, Ord, Read, Show) + +_ExclusiveOrExpression = Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression" + +_ExclusiveOrExpression_simple = Model.Name "simple" + +_ExclusiveOrExpression_binary = Model.Name "binary" + +-- | An explicitly typed parameter of an anonymous function, with an optional modifier. +data ExplicitAnonymousFunctionParameter = + ExplicitAnonymousFunctionParameter { + explicitAnonymousFunctionParameterModifier :: (Maybe AnonymousFunctionParameterModifier), + explicitAnonymousFunctionParameterType :: Type, + explicitAnonymousFunctionParameterIdentifier :: Identifier} + deriving (Eq, Ord, Read, Show) + +_ExplicitAnonymousFunctionParameter = Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter" + +_ExplicitAnonymousFunctionParameter_modifier = Model.Name "modifier" + +_ExplicitAnonymousFunctionParameter_type = Model.Name "type" + +_ExplicitAnonymousFunctionParameter_identifier = Model.Name "identifier" + +-- | A local variable declaration whose type is written out explicitly. +data ExplicitlyTypedLocalVariableDeclaration = + ExplicitlyTypedLocalVariableDeclaration { + explicitlyTypedLocalVariableDeclarationType :: Type, + explicitlyTypedLocalVariableDeclarationDeclarators :: [ExplicitlyTypedLocalVariableDeclarator]} + deriving (Eq, Ord, Read, Show) + +_ExplicitlyTypedLocalVariableDeclaration = Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration" + +_ExplicitlyTypedLocalVariableDeclaration_type = Model.Name "type" + +_ExplicitlyTypedLocalVariableDeclaration_declarators = Model.Name "declarators" + +-- | An identifier and optional initializer within an explicitly typed local declaration. +data ExplicitlyTypedLocalVariableDeclarator = + ExplicitlyTypedLocalVariableDeclarator { + explicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier, + explicitlyTypedLocalVariableDeclaratorInitializer :: (Maybe LocalVariableInitializer)} + deriving (Eq, Ord, Read, Show) + +_ExplicitlyTypedLocalVariableDeclarator = Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator" + +_ExplicitlyTypedLocalVariableDeclarator_identifier = Model.Name "identifier" + +_ExplicitlyTypedLocalVariableDeclarator_initializer = Model.Name "initializer" + +-- | A non-assignment expression or an assignment expression. +data Expression = + ExpressionNonAssignment NonAssignmentExpression | + ExpressionAssignment Assignment + deriving (Eq, Ord, Read, Show) + +_Expression = Model.Name "hydra.ext.csharp.syntax.Expression" + +_Expression_nonAssignment = Model.Name "nonAssignment" + +_Expression_assignment = Model.Name "assignment" + +-- | A non-empty, comma-separated list of expressions, as used in an array creation expression. +newtype ExpressionList = + ExpressionList { + unExpressionList :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_ExpressionList = Model.Name "hydra.ext.csharp.syntax.ExpressionList" + +-- | An 'extern alias' directive introducing an alias for an external assembly reference. +newtype ExternAliasDirective = + ExternAliasDirective { + unExternAliasDirective :: Identifier} + deriving (Eq, Ord, Read, Show) + +_ExternAliasDirective = Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective" + +-- | A field member declaration, with its modifiers, type, and one or more variable declarators. +data FieldDeclaration = + FieldDeclaration { + fieldDeclarationAttributes :: (Maybe Attributes), + fieldDeclarationModifiers :: [FieldModifier], + fieldDeclarationType :: Type, + fieldDeclarationDeclarators :: [VariableDeclarator]} + deriving (Eq, Ord, Read, Show) + +_FieldDeclaration = Model.Name "hydra.ext.csharp.syntax.FieldDeclaration" + +_FieldDeclaration_attributes = Model.Name "attributes" + +_FieldDeclaration_modifiers = Model.Name "modifiers" + +_FieldDeclaration_type = Model.Name "type" + +_FieldDeclaration_declarators = Model.Name "declarators" + +-- | A modifier keyword on a field declaration, such as static, readonly, or volatile. +data FieldModifier = + FieldModifierNew | + FieldModifierPublic | + FieldModifierProtected | + FieldModifierInternal | + FieldModifierPrivate | + FieldModifierStatic | + FieldModifierReadonly | + FieldModifierVolatile | + FieldModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_FieldModifier = Model.Name "hydra.ext.csharp.syntax.FieldModifier" + +_FieldModifier_new = Model.Name "new" + +_FieldModifier_public = Model.Name "public" + +_FieldModifier_protected = Model.Name "protected" + +_FieldModifier_internal = Model.Name "internal" + +_FieldModifier_private = Model.Name "private" + +_FieldModifier_static = Model.Name "static" + +_FieldModifier_readonly = Model.Name "readonly" + +_FieldModifier_volatile = Model.Name "volatile" + +_FieldModifier_unsafe = Model.Name "unsafe" + +-- | The body of a finalizer: a block, expression body, or empty (extern) body. +data FinalizerBody = + FinalizerBodyBlock Block | + FinalizerBodyExpression Expression | + FinalizerBodyEmpty + deriving (Eq, Ord, Read, Show) + +_FinalizerBody = Model.Name "hydra.ext.csharp.syntax.FinalizerBody" + +_FinalizerBody_block = Model.Name "block" + +_FinalizerBody_expression = Model.Name "expression" + +_FinalizerBody_empty = Model.Name "empty" + +-- | A finalizer (destructor) declaration, with its extern/unsafe flags, name, and body. +data FinalizerDeclaration = + FinalizerDeclaration { + finalizerDeclarationAttributes :: (Maybe Attributes), + finalizerDeclarationExtern :: Bool, + finalizerDeclarationUnsafe :: Bool, + finalizerDeclarationName :: Identifier, + finalizerDeclarationBody :: FinalizerBody} + deriving (Eq, Ord, Read, Show) + +_FinalizerDeclaration = Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration" + +_FinalizerDeclaration_attributes = Model.Name "attributes" + +_FinalizerDeclaration_extern = Model.Name "extern" + +_FinalizerDeclaration_unsafe = Model.Name "unsafe" + +_FinalizerDeclaration_name = Model.Name "name" + +_FinalizerDeclaration_body = Model.Name "body" + +-- | A single by-value or by-reference formal parameter, with optional attributes and a default value. +data FixedParameter = + FixedParameter { + fixedParameterAttributes :: (Maybe Attributes), + fixedParameterModifier :: (Maybe ParameterModifier), + fixedParameterType :: Type, + fixedParameterIdentifier :: Identifier, + fixedParameterDefaultArgument :: (Maybe Expression)} + deriving (Eq, Ord, Read, Show) + +_FixedParameter = Model.Name "hydra.ext.csharp.syntax.FixedParameter" + +_FixedParameter_attributes = Model.Name "attributes" + +_FixedParameter_modifier = Model.Name "modifier" + +_FixedParameter_type = Model.Name "type" + +_FixedParameter_identifier = Model.Name "identifier" + +_FixedParameter_defaultArgument = Model.Name "defaultArgument" + +-- | A single declarator in a fixed statement, binding a pointer to a variable or expression. +data FixedPointerDeclarator = + FixedPointerDeclaratorReference VariableReference | + FixedPointerDeclaratorExpression Expression + deriving (Eq, Ord, Read, Show) + +_FixedPointerDeclarator = Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator" + +_FixedPointerDeclarator_reference = Model.Name "reference" + +_FixedPointerDeclarator_expression = Model.Name "expression" + +-- | An unsafe fixed-size buffer field declaration inside a struct. +data FixedSizeBufferDeclaration = + FixedSizeBufferDeclaration { + fixedSizeBufferDeclarationAttributes :: (Maybe Attributes), + fixedSizeBufferDeclarationModifiers :: [FixedSizeBufferModifier], + fixedSizeBufferDeclarationElementType :: Type, + fixedSizeBufferDeclarationDeclarators :: [FixedSizeBufferDeclarator]} + deriving (Eq, Ord, Read, Show) + +_FixedSizeBufferDeclaration = Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration" + +_FixedSizeBufferDeclaration_attributes = Model.Name "attributes" + +_FixedSizeBufferDeclaration_modifiers = Model.Name "modifiers" + +_FixedSizeBufferDeclaration_elementType = Model.Name "elementType" + +_FixedSizeBufferDeclaration_declarators = Model.Name "declarators" + +-- | The name and constant size of a single fixed-size buffer member. +data FixedSizeBufferDeclarator = + FixedSizeBufferDeclarator { + fixedSizeBufferDeclaratorName :: Identifier, + fixedSizeBufferDeclaratorSize :: ConstantExpression} + deriving (Eq, Ord, Read, Show) + +_FixedSizeBufferDeclarator = Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator" + +_FixedSizeBufferDeclarator_name = Model.Name "name" + +_FixedSizeBufferDeclarator_size = Model.Name "size" + +-- | An access or unsafe modifier on a fixed-size buffer declaration. +data FixedSizeBufferModifier = + FixedSizeBufferModifierNew | + FixedSizeBufferModifierPublic | + FixedSizeBufferModifierInternal | + FixedSizeBufferModifierPrivate | + FixedSizeBufferModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_FixedSizeBufferModifier = Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier" + +_FixedSizeBufferModifier_new = Model.Name "new" + +_FixedSizeBufferModifier_public = Model.Name "public" + +_FixedSizeBufferModifier_internal = Model.Name "internal" + +_FixedSizeBufferModifier_private = Model.Name "private" + +_FixedSizeBufferModifier_unsafe = Model.Name "unsafe" + +-- | An unsafe 'fixed' statement that pins one or more variables for pointer access. +data FixedStatement = + FixedStatement { + fixedStatementPointerType :: PointerType, + fixedStatementDeclarators :: [FixedPointerDeclarator], + fixedStatementStatement :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_FixedStatement = Model.Name "hydra.ext.csharp.syntax.FixedStatement" + +_FixedStatement_pointerType = Model.Name "pointerType" + +_FixedStatement_declarators = Model.Name "declarators" + +_FixedStatement_statement = Model.Name "statement" + +-- | The float or double floating-point numeric type. +data FloatingPointType = + FloatingPointTypeFloat | + FloatingPointTypeDouble + deriving (Eq, Ord, Read, Show) + +_FloatingPointType = Model.Name "hydra.ext.csharp.syntax.FloatingPointType" + +_FloatingPointType_float = Model.Name "float" + +_FloatingPointType_double = Model.Name "double" + +-- | The initializer clause of a for statement: a local variable declaration or expression list. +data ForInitializer = + ForInitializerVariable LocalVariableDeclaration | + ForInitializerStatements StatementExpressionList + deriving (Eq, Ord, Read, Show) + +_ForInitializer = Model.Name "hydra.ext.csharp.syntax.ForInitializer" + +_ForInitializer_variable = Model.Name "variable" + +_ForInitializer_statements = Model.Name "statements" + +-- | A C-style for loop, with optional initializer, condition, iterator, and a body statement. +data ForStatement = + ForStatement { + forStatementInitializer :: (Maybe ForInitializer), + forStatementCondition :: (Maybe BooleanExpression), + forStatementIterator :: (Maybe StatementExpressionList), + forStatementBody :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_ForStatement = Model.Name "hydra.ext.csharp.syntax.ForStatement" + +_ForStatement_initializer = Model.Name "initializer" + +_ForStatement_condition = Model.Name "condition" + +_ForStatement_iterator = Model.Name "iterator" + +_ForStatement_body = Model.Name "body" + +-- | A foreach iteration statement over an enumerable expression, binding each element to a variable. +data ForeachStatement = + ForeachStatement { + foreachStatementKind :: (Maybe RefKind), + foreachStatementType :: LocalVariableType, + foreachStatementIdentifier :: Identifier, + foreachStatementExpression :: Expression, + foreachStatementBody :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_ForeachStatement = Model.Name "hydra.ext.csharp.syntax.ForeachStatement" + +_ForeachStatement_kind = Model.Name "kind" + +_ForeachStatement_type = Model.Name "type" + +_ForeachStatement_identifier = Model.Name "identifier" + +_ForeachStatement_expression = Model.Name "expression" + +_ForeachStatement_body = Model.Name "body" + +-- | The fixed parameters of a member, plus an optional trailing params array parameter. +data FormalParameterList = + FormalParameterList { + formalParameterListFixed :: [FixedParameter], + formalParameterListArray :: (Maybe ParameterArray)} + deriving (Eq, Ord, Read, Show) + +_FormalParameterList = Model.Name "hydra.ext.csharp.syntax.FormalParameterList" + +_FormalParameterList_fixed = Model.Name "fixed" + +_FormalParameterList_array = Model.Name "array" + +-- | The initial or additional 'from' clause of a query expression, introducing a range variable. +data FromClause = + FromClause { + fromClauseType :: (Maybe Type), + fromClauseIdentifier :: Identifier, + fromClauseIn :: Expression} + deriving (Eq, Ord, Read, Show) + +_FromClause = Model.Name "hydra.ext.csharp.syntax.FromClause" + +_FromClause_type = Model.Name "type" + +_FromClause_identifier = Model.Name "identifier" + +_FromClause_in = Model.Name "in" + +-- | An assembly- or module-level attribute section appearing at the top of a compilation unit. +data GlobalAttributeSection = + GlobalAttributeSection { + globalAttributeSectionTarget :: Identifier, + globalAttributeSectionAttributes :: AttributeList} + deriving (Eq, Ord, Read, Show) + +_GlobalAttributeSection = Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection" + +_GlobalAttributeSection_target = Model.Name "target" + +_GlobalAttributeSection_attributes = Model.Name "attributes" + +-- | A goto statement targeting a label, a switch case, or the switch default section. +data GotoStatement = + GotoStatementIdentifier Identifier | + GotoStatementCase ConstantExpression | + GotoStatementDefault + deriving (Eq, Ord, Read, Show) + +_GotoStatement = Model.Name "hydra.ext.csharp.syntax.GotoStatement" + +_GotoStatement_identifier = Model.Name "identifier" + +_GotoStatement_case = Model.Name "case" + +_GotoStatement_default = Model.Name "default" + +-- | The 'group ... by ...' clause that ends a query expression, producing grouped results. +data GroupClause = + GroupClause { + groupClauseGrouped :: Expression, + groupClauseBy :: Expression} + deriving (Eq, Ord, Read, Show) + +_GroupClause = Model.Name "hydra.ext.csharp.syntax.GroupClause" + +_GroupClause_grouped = Model.Name "grouped" + +_GroupClause_by = Model.Name "by" + +-- | A C# identifier: a name for a variable, type, member, or other program element. +newtype Identifier = + Identifier { + unIdentifier :: String} + deriving (Eq, Ord, Read, Show) + +_Identifier = Model.Name "hydra.ext.csharp.syntax.Identifier" + +-- | A simple namespace-or-type name consisting of an identifier and optional type arguments. +data IdentifierNamespaceOrTypeName = + IdentifierNamespaceOrTypeName { + identifierNamespaceOrTypeNameIdentifier :: Identifier, + identifierNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_IdentifierNamespaceOrTypeName = Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName" + +_IdentifierNamespaceOrTypeName_identifier = Model.Name "identifier" + +_IdentifierNamespaceOrTypeName_arguments = Model.Name "arguments" + +-- | An if statement with a boolean condition, a then-branch, and an else-branch. +data IfStatement = + IfStatement { + ifStatementCondition :: BooleanExpression, + ifStatementIfBranch :: EmbeddedStatement, + ifStatementElseBranch :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_IfStatement = Model.Name "hydra.ext.csharp.syntax.IfStatement" + +_IfStatement_condition = Model.Name "condition" + +_IfStatement_ifBranch = Model.Name "ifBranch" + +_IfStatement_elseBranch = Model.Name "elseBranch" + +-- | A local variable declaration using 'var' with inferred type, plain or ref. +data ImplicitlyTypedLocalVariableDeclaration = + ImplicitlyTypedLocalVariableDeclarationVar ImplicitlyTypedLocalVariableDeclarator | + ImplicitlyTypedLocalVariableDeclarationRefVar RefVarImplicitlyTypedLocalVariableDeclaration + deriving (Eq, Ord, Read, Show) + +_ImplicitlyTypedLocalVariableDeclaration = Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration" + +_ImplicitlyTypedLocalVariableDeclaration_var = Model.Name "var" + +_ImplicitlyTypedLocalVariableDeclaration_refVar = Model.Name "refVar" + +-- | The identifier and initializer expression of a 'var'-typed local variable. +data ImplicitlyTypedLocalVariableDeclarator = + ImplicitlyTypedLocalVariableDeclarator { + implicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier, + implicitlyTypedLocalVariableDeclaratorExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_ImplicitlyTypedLocalVariableDeclarator = Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator" + +_ImplicitlyTypedLocalVariableDeclarator_identifier = Model.Name "identifier" + +_ImplicitlyTypedLocalVariableDeclarator_expression = Model.Name "expression" + +-- | A simple exclusive-OR expression or a binary bitwise inclusive-OR (|) expression. +data InclusiveOrExpression = + InclusiveOrExpressionSimple ExclusiveOrExpression | + InclusiveOrExpressionBinary BinaryInclusiveOrExpression + deriving (Eq, Ord, Read, Show) + +_InclusiveOrExpression = Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression" + +_InclusiveOrExpression_simple = Model.Name "simple" + +_InclusiveOrExpression_binary = Model.Name "binary" + +-- | The body of a standard indexer: block accessors or a single expression body. +data IndexerBody = + IndexerBodyBlock AccessorDeclarations | + IndexerBodyExpression Expression + deriving (Eq, Ord, Read, Show) + +_IndexerBody = Model.Name "hydra.ext.csharp.syntax.IndexerBody" + +_IndexerBody_block = Model.Name "block" + +_IndexerBody_expression = Model.Name "expression" + +-- | An indexer member declaration, in its standard or ref-returning form. +data IndexerDeclaration = + IndexerDeclarationStandard StandardIndexerDeclaration | + IndexerDeclarationRef RefIndexerDeclaration + deriving (Eq, Ord, Read, Show) + +_IndexerDeclaration = Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration" + +_IndexerDeclaration_standard = Model.Name "standard" + +_IndexerDeclaration_ref = Model.Name "ref" + +-- | An indexer's declared type, optional explicit interface, and formal parameter list. +data IndexerDeclarator = + IndexerDeclarator { + indexerDeclaratorType :: Type, + indexerDeclaratorInterface :: (Maybe InterfaceType), + indexerDeclaratorParameters :: FormalParameterList} + deriving (Eq, Ord, Read, Show) + +_IndexerDeclarator = Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator" + +_IndexerDeclarator_type = Model.Name "type" + +_IndexerDeclarator_interface = Model.Name "interface" + +_IndexerDeclarator_parameters = Model.Name "parameters" + +-- | A modifier keyword on an indexer declaration, such as virtual, override, or abstract. +data IndexerModifier = + IndexerModifierNew | + IndexerModifierPublic | + IndexerModifierProtected | + IndexerModifierInternal | + IndexerModifierPrivate | + IndexerModifierVirtual | + IndexerModifierSealed | + IndexerModifierOverride | + IndexerModifierAbstract | + IndexerModifierExtern | + IndexerModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_IndexerModifier = Model.Name "hydra.ext.csharp.syntax.IndexerModifier" + +_IndexerModifier_new = Model.Name "new" + +_IndexerModifier_public = Model.Name "public" + +_IndexerModifier_protected = Model.Name "protected" + +_IndexerModifier_internal = Model.Name "internal" + +_IndexerModifier_private = Model.Name "private" + +_IndexerModifier_virtual = Model.Name "virtual" + +_IndexerModifier_sealed = Model.Name "sealed" + +_IndexerModifier_override = Model.Name "override" + +_IndexerModifier_abstract = Model.Name "abstract" + +_IndexerModifier_extern = Model.Name "extern" + +_IndexerModifier_unsafe = Model.Name "unsafe" + +-- | The left-hand side of a member initializer: an identifier or an indexer argument list. +data InitializerTarget = + InitializerTargetIdentifier Identifier | + InitializerTargetArguments ArgumentList + deriving (Eq, Ord, Read, Show) + +_InitializerTarget = Model.Name "hydra.ext.csharp.syntax.InitializerTarget" + +_InitializerTarget_identifier = Model.Name "identifier" + +_InitializerTarget_arguments = Model.Name "arguments" + +-- | The right-hand side of a member initializer: an expression or a nested collection initializer. +data InitializerValue = + InitializerValueExpression Expression | + InitializerValueObjectOrCollection ObjectOrCollectionInitializer + deriving (Eq, Ord, Read, Show) + +_InitializerValue = Model.Name "hydra.ext.csharp.syntax.InitializerValue" + +_InitializerValue_expression = Model.Name "expression" + +_InitializerValue_objectOrCollection = Model.Name "objectOrCollection" + +-- | An integer literal, expressed in decimal, hexadecimal, or binary notation. +data IntegerLiteral = + IntegerLiteralDecimal String | + IntegerLiteralHexadecimal String | + IntegerLiteralBinary Integer + deriving (Eq, Ord, Read, Show) + +_IntegerLiteral = Model.Name "hydra.ext.csharp.syntax.IntegerLiteral" + +_IntegerLiteral_decimal = Model.Name "decimal" + +_IntegerLiteral_hexadecimal = Model.Name "hexadecimal" + +_IntegerLiteral_binary = Model.Name "binary" + +-- | One of the built-in integral numeric types (sbyte through char). +data IntegralType = + IntegralTypeSbyte | + IntegralTypeByte | + IntegralTypeShort | + IntegralTypeUshort | + IntegralTypeInt | + IntegralTypeUint | + IntegralTypeLong | + IntegralTypeUlong | + IntegralTypeChar + deriving (Eq, Ord, Read, Show) + +_IntegralType = Model.Name "hydra.ext.csharp.syntax.IntegralType" + +_IntegralType_sbyte = Model.Name "sbyte" + +_IntegralType_byte = Model.Name "byte" + +_IntegralType_short = Model.Name "short" + +_IntegralType_ushort = Model.Name "ushort" + +_IntegralType_int = Model.Name "int" + +_IntegralType_uint = Model.Name "uint" + +_IntegralType_long = Model.Name "long" + +_IntegralType_ulong = Model.Name "ulong" + +_IntegralType_char = Model.Name "char" + +-- | The get and/or set accessor attribute lists declared by an interface property or indexer. +data InterfaceAccessors = + InterfaceAccessors { + interfaceAccessorsAttributes :: (Maybe Attributes), + interfaceAccessorsGet :: (Maybe Attributes), + interfaceAccessorsSet :: (Maybe Attributes)} + deriving (Eq, Ord, Read, Show) + +_InterfaceAccessors = Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors" + +_InterfaceAccessors_attributes = Model.Name "attributes" + +_InterfaceAccessors_get = Model.Name "get" + +_InterfaceAccessors_set = Model.Name "set" + +-- | An interface type declaration, with its modifiers, type parameters, base interfaces, and members. +data InterfaceDeclaration = + InterfaceDeclaration { + interfaceDeclarationAttributes :: (Maybe Attributes), + interfaceDeclarationModifiers :: [InterfaceModifier], + interfaceDeclarationPartial :: Bool, + interfaceDeclarationName :: Identifier, + interfaceDeclarationParameters :: (Maybe VariantTypeParameters), + interfaceDeclarationBase :: [InterfaceType], + interfaceDeclarationConstraints :: [TypeParameterConstraintsClause], + interfaceDeclarationBody :: [InterfaceMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_InterfaceDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration" + +_InterfaceDeclaration_attributes = Model.Name "attributes" + +_InterfaceDeclaration_modifiers = Model.Name "modifiers" + +_InterfaceDeclaration_partial = Model.Name "partial" + +_InterfaceDeclaration_name = Model.Name "name" + +_InterfaceDeclaration_parameters = Model.Name "parameters" + +_InterfaceDeclaration_base = Model.Name "base" + +_InterfaceDeclaration_constraints = Model.Name "constraints" + +_InterfaceDeclaration_body = Model.Name "body" + +-- | An event member declared within an interface body. +data InterfaceEventDeclaration = + InterfaceEventDeclaration { + interfaceEventDeclarationAttributes :: (Maybe Attributes), + interfaceEventDeclarationNew :: Bool, + interfaceEventDeclarationType :: Type, + interfaceEventDeclarationName :: Identifier} + deriving (Eq, Ord, Read, Show) + +_InterfaceEventDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration" + +_InterfaceEventDeclaration_attributes = Model.Name "attributes" + +_InterfaceEventDeclaration_new = Model.Name "new" + +_InterfaceEventDeclaration_type = Model.Name "type" + +_InterfaceEventDeclaration_name = Model.Name "name" + +-- | An indexer member declared within an interface body. +data InterfaceIndexerDeclaration = + InterfaceIndexerDeclaration { + interfaceIndexerDeclarationAttributes :: (Maybe Attributes), + interfaceIndexerDeclarationNew :: Bool, + interfaceIndexerDeclarationRefKind :: (Maybe RefKind), + interfaceIndexerDeclarationType :: Type, + interfaceIndexerDeclarationParameters :: FormalParameterList, + interfaceIndexerDeclarationAccessors :: InterfaceAccessors} + deriving (Eq, Ord, Read, Show) + +_InterfaceIndexerDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration" + +_InterfaceIndexerDeclaration_attributes = Model.Name "attributes" + +_InterfaceIndexerDeclaration_new = Model.Name "new" + +_InterfaceIndexerDeclaration_refKind = Model.Name "refKind" + +_InterfaceIndexerDeclaration_type = Model.Name "type" + +_InterfaceIndexerDeclaration_parameters = Model.Name "parameters" + +_InterfaceIndexerDeclaration_accessors = Model.Name "accessors" + +-- | Any member that can appear in an interface body: method, property, event, or indexer. +data InterfaceMemberDeclaration = + InterfaceMemberDeclarationMethod InterfaceMethodDeclaration | + InterfaceMemberDeclarationProperty InterfacePropertyDeclaration | + InterfaceMemberDeclarationEvent InterfaceEventDeclaration | + InterfaceMemberDeclarationIndexer InterfaceIndexerDeclaration + deriving (Eq, Ord, Read, Show) + +_InterfaceMemberDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration" + +_InterfaceMemberDeclaration_method = Model.Name "method" + +_InterfaceMemberDeclaration_property = Model.Name "property" + +_InterfaceMemberDeclaration_event = Model.Name "event" + +_InterfaceMemberDeclaration_indexer = Model.Name "indexer" + +-- | A method member declared within an interface body. +data InterfaceMethodDeclaration = + InterfaceMethodDeclaration { + interfaceMethodDeclarationAttributes :: (Maybe Attributes), + interfaceMethodDeclarationNew :: Bool, + interfaceMethodDeclarationReturnType :: ReturnType, + interfaceMethodDeclarationRefKind :: (Maybe RefKind), + interfaceMethodDeclarationHeader :: InterfaceMethodHeader} + deriving (Eq, Ord, Read, Show) + +_InterfaceMethodDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration" + +_InterfaceMethodDeclaration_attributes = Model.Name "attributes" + +_InterfaceMethodDeclaration_new = Model.Name "new" + +_InterfaceMethodDeclaration_returnType = Model.Name "returnType" + +_InterfaceMethodDeclaration_refKind = Model.Name "refKind" + +_InterfaceMethodDeclaration_header = Model.Name "header" + +-- | The name, parameters, type parameters, and constraints of an interface method declaration. +data InterfaceMethodHeader = + InterfaceMethodHeader { + interfaceMethodHeaderName :: Identifier, + interfaceMethodHeaderParameters :: (Maybe FormalParameterList), + interfaceMethodHeaderTypeParameters :: (Maybe TypeParameterList), + interfaceMethodHeaderConstraints :: [TypeParameterConstraintsClause]} + deriving (Eq, Ord, Read, Show) + +_InterfaceMethodHeader = Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader" + +_InterfaceMethodHeader_name = Model.Name "name" + +_InterfaceMethodHeader_parameters = Model.Name "parameters" + +_InterfaceMethodHeader_typeParameters = Model.Name "typeParameters" + +_InterfaceMethodHeader_constraints = Model.Name "constraints" + +-- | An access or unsafe modifier on an interface declaration. +data InterfaceModifier = + InterfaceModifierNew | + InterfaceModifierPublic | + InterfaceModifierProtected | + InterfaceModifierInternal | + InterfaceModifierPrivate | + InterfaceModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_InterfaceModifier = Model.Name "hydra.ext.csharp.syntax.InterfaceModifier" + +_InterfaceModifier_new = Model.Name "new" + +_InterfaceModifier_public = Model.Name "public" + +_InterfaceModifier_protected = Model.Name "protected" + +_InterfaceModifier_internal = Model.Name "internal" + +_InterfaceModifier_private = Model.Name "private" + +_InterfaceModifier_unsafe = Model.Name "unsafe" + +-- | A property member declared within an interface body. +data InterfacePropertyDeclaration = + InterfacePropertyDeclaration { + interfacePropertyDeclarationAttributes :: (Maybe Attributes), + interfacePropertyDeclarationNew :: Bool, + interfacePropertyDeclarationRefKind :: (Maybe RefKind), + interfacePropertyDeclarationType :: Type, + interfacePropertyDeclarationName :: Identifier, + interfacePropertyDeclarationAccessors :: InterfaceAccessors} + deriving (Eq, Ord, Read, Show) + +_InterfacePropertyDeclaration = Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration" + +_InterfacePropertyDeclaration_attributes = Model.Name "attributes" + +_InterfacePropertyDeclaration_new = Model.Name "new" + +_InterfacePropertyDeclaration_refKind = Model.Name "refKind" + +_InterfacePropertyDeclaration_type = Model.Name "type" + +_InterfacePropertyDeclaration_name = Model.Name "name" + +_InterfacePropertyDeclaration_accessors = Model.Name "accessors" + +-- | A reference to an interface type by its type name. +newtype InterfaceType = + InterfaceType { + unInterfaceType :: TypeName} + deriving (Eq, Ord, Read, Show) + +_InterfaceType = Model.Name "hydra.ext.csharp.syntax.InterfaceType" + +-- | An interpolated string literal delimited by ordinary double quotes. +newtype InterpolatedRegularStringExpression = + InterpolatedRegularStringExpression { + unInterpolatedRegularStringExpression :: String} + deriving (Eq, Ord, Read, Show) + +_InterpolatedRegularStringExpression = Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression" + +-- | An interpolated string expression, in its regular or verbatim quoting form. +data InterpolatedStringExpression = + InterpolatedStringExpressionRegular InterpolatedRegularStringExpression | + InterpolatedStringExpressionVerbatim InterpolatedVerbatimStringExpression + deriving (Eq, Ord, Read, Show) + +_InterpolatedStringExpression = Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression" + +_InterpolatedStringExpression_regular = Model.Name "regular" + +_InterpolatedStringExpression_verbatim = Model.Name "verbatim" + +-- | An interpolated string literal using verbatim, at-sign-prefixed quoting. +newtype InterpolatedVerbatimStringExpression = + InterpolatedVerbatimStringExpression { + unInterpolatedVerbatimStringExpression :: String} + deriving (Eq, Ord, Read, Show) + +_InterpolatedVerbatimStringExpression = Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression" + +-- | A method or delegate invocation: a primary expression applied to an argument list. +data InvocationExpression = + InvocationExpression { + invocationExpressionExpression :: PrimaryExpression, + invocationExpressionArguments :: (Maybe ArgumentList)} + deriving (Eq, Ord, Read, Show) + +_InvocationExpression = Model.Name "hydra.ext.csharp.syntax.InvocationExpression" + +_InvocationExpression_expression = Model.Name "expression" + +_InvocationExpression_arguments = Model.Name "arguments" + +-- | An 'is' pattern-matching expression testing a relational expression against a pattern. +data IsPatternExpression = + IsPatternExpression { + isPatternExpressionExpression :: RelationalExpression, + isPatternExpressionPattern :: Pattern} + deriving (Eq, Ord, Read, Show) + +_IsPatternExpression = Model.Name "hydra.ext.csharp.syntax.IsPatternExpression" + +_IsPatternExpression_expression = Model.Name "expression" + +_IsPatternExpression_pattern = Model.Name "pattern" + +-- | An 'is' type-testing expression checking whether an expression is of a given type. +data IsTypeExpression = + IsTypeExpression { + isTypeExpressionExpression :: RelationalExpression, + isTypeExpressionType :: Type} + deriving (Eq, Ord, Read, Show) + +_IsTypeExpression = Model.Name "hydra.ext.csharp.syntax.IsTypeExpression" + +_IsTypeExpression_expression = Model.Name "expression" + +_IsTypeExpression_type = Model.Name "type" + +-- | A while, do, for, or foreach loop statement. +data IterationStatement = + IterationStatementWhile WhileStatement | + IterationStatementDo DoStatement | + IterationStatementFor ForStatement | + IterationStatementForeach ForeachStatement + deriving (Eq, Ord, Read, Show) + +_IterationStatement = Model.Name "hydra.ext.csharp.syntax.IterationStatement" + +_IterationStatement_while = Model.Name "while" + +_IterationStatement_do = Model.Name "do" + +_IterationStatement_for = Model.Name "for" + +_IterationStatement_foreach = Model.Name "foreach" + +-- | A 'join' clause in a query expression, correlating two sequences on matching keys. +data JoinClause = + JoinClause { + joinClauseType :: (Maybe Type), + joinClauseIdentifier :: Identifier, + joinClauseIn :: Expression, + joinClauseOn :: Expression, + joinClauseEquals :: Expression, + joinClauseInto :: (Maybe Identifier)} + deriving (Eq, Ord, Read, Show) + +_JoinClause = Model.Name "hydra.ext.csharp.syntax.JoinClause" + +_JoinClause_type = Model.Name "type" + +_JoinClause_identifier = Model.Name "identifier" + +_JoinClause_in = Model.Name "in" + +_JoinClause_on = Model.Name "on" + +_JoinClause_equals = Model.Name "equals" + +_JoinClause_into = Model.Name "into" + +-- | A break, continue, goto, return, or throw statement that transfers control. +data JumpStatement = + JumpStatementBreak | + JumpStatementContinue | + JumpStatementGoto GotoStatement | + JumpStatementReturn ReturnStatement | + JumpStatementThrow (Maybe Expression) + deriving (Eq, Ord, Read, Show) + +_JumpStatement = Model.Name "hydra.ext.csharp.syntax.JumpStatement" + +_JumpStatement_break = Model.Name "break" + +_JumpStatement_continue = Model.Name "continue" + +_JumpStatement_goto = Model.Name "goto" + +_JumpStatement_return = Model.Name "return" + +_JumpStatement_throw = Model.Name "throw" + +-- | A reserved C# keyword. +newtype Keyword = + Keyword { + unKeyword :: String} + deriving (Eq, Ord, Read, Show) + +_Keyword = Model.Name "hydra.ext.csharp.syntax.Keyword" + +-- | A statement prefixed with a label, usable as the target of a goto statement. +data LabeledStatement = + LabeledStatement { + labeledStatementLabel :: Identifier, + labeledStatementStatement :: Statement} + deriving (Eq, Ord, Read, Show) + +_LabeledStatement = Model.Name "hydra.ext.csharp.syntax.LabeledStatement" + +_LabeledStatement_label = Model.Name "label" + +_LabeledStatement_statement = Model.Name "statement" + +-- | A lambda expression, with its async flag, parameter signature, and body. +data LambdaExpression = + LambdaExpression { + lambdaExpressionAsync :: Bool, + lambdaExpressionSignature :: AnonymousFunctionSignature, + lambdaExpressionBody :: AnonymousFunctionBody} + deriving (Eq, Ord, Read, Show) + +_LambdaExpression = Model.Name "hydra.ext.csharp.syntax.LambdaExpression" + +_LambdaExpression_async = Model.Name "async" + +_LambdaExpression_signature = Model.Name "signature" + +_LambdaExpression_body = Model.Name "body" + +-- | A 'let' clause in a query expression that introduces a computed range variable. +data LetClause = + LetClause { + letClauseLeft :: Identifier, + letClauseRight :: Expression} + deriving (Eq, Ord, Read, Show) + +_LetClause = Model.Name "hydra.ext.csharp.syntax.LetClause" + +_LetClause_left = Model.Name "left" + +_LetClause_right = Model.Name "right" + +-- | A literal value: boolean, integer, real, character, string, or null. +data Literal = + LiteralBoolean Bool | + LiteralInteger IntegerLiteral | + LiteralReal Double | + LiteralCharacter String | + LiteralString String | + LiteralNull + deriving (Eq, Ord, Read, Show) + +_Literal = Model.Name "hydra.ext.csharp.syntax.Literal" + +_Literal_boolean = Model.Name "boolean" + +_Literal_integer = Model.Name "integer" + +_Literal_real = Model.Name "real" + +_Literal_character = Model.Name "character" + +_Literal_string = Model.Name "string" + +_Literal_null = Model.Name "null" + +-- | A 'const' local declaration with its type and one or more constant declarators. +data LocalConstantDeclaration = + LocalConstantDeclaration { + localConstantDeclarationType :: Type, + localConstantDeclarationDeclarators :: [ConstantDeclarator]} + deriving (Eq, Ord, Read, Show) + +_LocalConstantDeclaration = Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration" + +_LocalConstantDeclaration_type = Model.Name "type" + +_LocalConstantDeclaration_declarators = Model.Name "declarators" + +-- | The body of a local function: a block, null-conditional invocation, or expression. +data LocalFunctionBody = + LocalFunctionBodyBlock Block | + LocalFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression | + LocalFunctionBodyExpression Expression + deriving (Eq, Ord, Read, Show) + +_LocalFunctionBody = Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody" + +_LocalFunctionBody_block = Model.Name "block" + +_LocalFunctionBody_nullConditionalInvocation = Model.Name "nullConditionalInvocation" + +_LocalFunctionBody_expression = Model.Name "expression" + +-- | A local function declaration, in its standard or ref-returning form. +data LocalFunctionDeclaration = + LocalFunctionDeclarationStandard StandardLocalFunctionDeclaration | + LocalFunctionDeclarationRef RefLocalFunctionDeclaration + deriving (Eq, Ord, Read, Show) + +_LocalFunctionDeclaration = Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration" + +_LocalFunctionDeclaration_standard = Model.Name "standard" + +_LocalFunctionDeclaration_ref = Model.Name "ref" + +-- | The name, type parameters, formal parameters, and constraints of a local function. +data LocalFunctionHeader = + LocalFunctionHeader { + localFunctionHeaderIdentifier :: Identifier, + localFunctionHeaderTypeParameters :: (Maybe TypeParameterList), + localFunctionHeaderParameters :: FormalParameterList, + localFunctionHeaderConstraints :: [TypeParameterConstraintsClause]} + deriving (Eq, Ord, Read, Show) + +_LocalFunctionHeader = Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader" + +_LocalFunctionHeader_identifier = Model.Name "identifier" + +_LocalFunctionHeader_typeParameters = Model.Name "typeParameters" + +_LocalFunctionHeader_parameters = Model.Name "parameters" + +_LocalFunctionHeader_constraints = Model.Name "constraints" + +-- | A modifier on a local function declaration: a ref modifier, or 'async'. +data LocalFunctionModifier = + LocalFunctionModifierRef RefLocalFunctionModifier | + LocalFunctionModifierAsync + deriving (Eq, Ord, Read, Show) + +_LocalFunctionModifier = Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier" + +_LocalFunctionModifier_ref = Model.Name "ref" + +_LocalFunctionModifier_async = Model.Name "async" + +-- | A local variable declaration, in its implicitly typed, explicitly typed, or ref form. +data LocalVariableDeclaration = + LocalVariableDeclarationImplicitlyTyped ImplicitlyTypedLocalVariableDeclaration | + LocalVariableDeclarationExplicitlyTyped ExplicitlyTypedLocalVariableDeclaration | + LocalVariableDeclarationRef RefLocalVariableDeclaration + deriving (Eq, Ord, Read, Show) + +_LocalVariableDeclaration = Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration" + +_LocalVariableDeclaration_implicitlyTyped = Model.Name "implicitlyTyped" + +_LocalVariableDeclaration_explicitlyTyped = Model.Name "explicitlyTyped" + +_LocalVariableDeclaration_ref = Model.Name "ref" + +-- | The initializer of a local variable: an expression or an array initializer. +data LocalVariableInitializer = + LocalVariableInitializerExpression Expression | + LocalVariableInitializerInitializer ArrayInitializer + deriving (Eq, Ord, Read, Show) + +_LocalVariableInitializer = Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer" + +_LocalVariableInitializer_expression = Model.Name "expression" + +_LocalVariableInitializer_initializer = Model.Name "initializer" + +-- | The declared type of a local variable, or 'var' for implicit typing. +data LocalVariableType = + LocalVariableTypeType Type | + LocalVariableTypeVar + deriving (Eq, Ord, Read, Show) + +_LocalVariableType = Model.Name "hydra.ext.csharp.syntax.LocalVariableType" + +_LocalVariableType_type = Model.Name "type" + +_LocalVariableType_var = Model.Name "var" + +-- | A 'lock' statement that acquires a mutual-exclusion lock for the duration of its body. +data LockStatement = + LockStatement { + lockStatementExpression :: Expression, + lockStatementBody :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_LockStatement = Model.Name "hydra.ext.csharp.syntax.LockStatement" + +_LockStatement_expression = Model.Name "expression" + +_LockStatement_body = Model.Name "body" + +-- | A 'primary.identifier' member access, with optional explicit type arguments. +data MemberAccess = + MemberAccess { + memberAccessHead :: MemberAccessHead, + memberAccessIdentifier :: Identifier, + memberAccessTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_MemberAccess = Model.Name "hydra.ext.csharp.syntax.MemberAccess" + +_MemberAccess_head = Model.Name "head" + +_MemberAccess_identifier = Model.Name "identifier" + +_MemberAccess_typeArguments = Model.Name "typeArguments" + +-- | The left-hand target of a member access: a primary expression, predefined type, or alias. +data MemberAccessHead = + MemberAccessHeadPrimary PrimaryExpression | + MemberAccessHeadPredefined PredefinedType | + MemberAccessHeadQualifiedAlias QualifiedAliasMember + deriving (Eq, Ord, Read, Show) + +_MemberAccessHead = Model.Name "hydra.ext.csharp.syntax.MemberAccessHead" + +_MemberAccessHead_primary = Model.Name "primary" + +_MemberAccessHead_predefined = Model.Name "predefined" + +_MemberAccessHead_qualifiedAlias = Model.Name "qualifiedAlias" + +-- | A single member of an anonymous object initializer, naming or computing a member value. +data MemberDeclarator = + MemberDeclaratorName SimpleName | + MemberDeclaratorMemberAccess MemberAccess | + MemberDeclaratorNullConditionalProjectionInitializer NullConditionalProjectionInitializer | + MemberDeclaratorBaseAccess BaseAccess | + MemberDeclaratorAssignment AssignmentMemberDeclarator + deriving (Eq, Ord, Read, Show) + +_MemberDeclarator = Model.Name "hydra.ext.csharp.syntax.MemberDeclarator" + +_MemberDeclarator_name = Model.Name "name" + +_MemberDeclarator_memberAccess = Model.Name "memberAccess" + +_MemberDeclarator_nullConditionalProjectionInitializer = Model.Name "nullConditionalProjectionInitializer" + +_MemberDeclarator_baseAccess = Model.Name "baseAccess" + +_MemberDeclarator_assignment = Model.Name "assignment" + +-- | A non-empty, comma-separated list of member declarators in an anonymous object creation. +newtype MemberDeclaratorList = + MemberDeclaratorList { + unMemberDeclaratorList :: [MemberDeclarator]} + deriving (Eq, Ord, Read, Show) + +_MemberDeclaratorList = Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList" + +-- | A 'target = value' pair within an object initializer. +data MemberInitializer = + MemberInitializer { + memberInitializerTarget :: InitializerTarget, + memberInitializerValue :: InitializerValue} + deriving (Eq, Ord, Read, Show) + +_MemberInitializer = Model.Name "hydra.ext.csharp.syntax.MemberInitializer" + +_MemberInitializer_target = Model.Name "target" + +_MemberInitializer_value = Model.Name "value" + +-- | A member's declared name, with an optional explicit interface type qualifier. +data MemberName = + MemberName { + memberNameInterfaceType :: (Maybe TypeName), + memberNameIdentifier :: Identifier} + deriving (Eq, Ord, Read, Show) + +_MemberName = Model.Name "hydra.ext.csharp.syntax.MemberName" + +_MemberName_interfaceType = Model.Name "interfaceType" + +_MemberName_identifier = Model.Name "identifier" + +-- | The body of a standard method: a block, null-conditional invocation, expression, or empty. +data MethodBody = + MethodBodyBlock Block | + MethodBodyNullConditionalInvocation NullConditionalInvocationExpression | + MethodBodyExpression Expression | + MethodBodyEmpty + deriving (Eq, Ord, Read, Show) + +_MethodBody = Model.Name "hydra.ext.csharp.syntax.MethodBody" + +_MethodBody_block = Model.Name "block" + +_MethodBody_nullConditionalInvocation = Model.Name "nullConditionalInvocation" + +_MethodBody_expression = Model.Name "expression" + +_MethodBody_empty = Model.Name "empty" + +-- | A method member declaration, in its standard or ref-returning form. +data MethodDeclaration = + MethodDeclarationStandard StandardMethodDeclaration | + MethodDeclarationRefReturn RefReturnMethodDeclaration + deriving (Eq, Ord, Read, Show) + +_MethodDeclaration = Model.Name "hydra.ext.csharp.syntax.MethodDeclaration" + +_MethodDeclaration_standard = Model.Name "standard" + +_MethodDeclaration_refReturn = Model.Name "refReturn" + +-- | The name, type parameters, formal parameters, and constraints of a method declaration. +data MethodHeader = + MethodHeader { + methodHeaderName :: MemberName, + methodHeaderTypeParameters :: (Maybe TypeParameterList), + methodHeaderParameters :: (Maybe FormalParameterList), + methodHeaderConstraints :: [TypeParameterConstraintsClause]} + deriving (Eq, Ord, Read, Show) + +_MethodHeader = Model.Name "hydra.ext.csharp.syntax.MethodHeader" + +_MethodHeader_name = Model.Name "name" + +_MethodHeader_typeParameters = Model.Name "typeParameters" + +_MethodHeader_parameters = Model.Name "parameters" + +_MethodHeader_constraints = Model.Name "constraints" + +-- | A modifier on a method declaration: a ref modifier, or 'async'. +data MethodModifier = + MethodModifierRef RefMethodModifier | + MethodModifierAsync + deriving (Eq, Ord, Read, Show) + +_MethodModifier = Model.Name "hydra.ext.csharp.syntax.MethodModifier" + +_MethodModifier_ref = Model.Name "ref" + +_MethodModifier_async = Model.Name "async" + +-- | The full modifier list of a method declaration, including whether it is 'partial'. +data MethodModifiers = + MethodModifiers { + methodModifiersModifiers :: [MethodModifier], + methodModifiersPartial :: Bool} + deriving (Eq, Ord, Read, Show) + +_MethodModifiers = Model.Name "hydra.ext.csharp.syntax.MethodModifiers" + +_MethodModifiers_modifiers = Model.Name "modifiers" + +_MethodModifiers_partial = Model.Name "partial" + +-- | A simple unary expression or a binary multiplication/division/remainder expression. +data MultiplicativeExpression = + MultiplicativeExpressionSimple UnaryExpression | + MultiplicativeExpressionBinary BinaryMultiplicativeExpression + deriving (Eq, Ord, Read, Show) + +_MultiplicativeExpression = Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression" + +_MultiplicativeExpression_simple = Model.Name "simple" + +_MultiplicativeExpression_binary = Model.Name "binary" + +-- | The multiplication, division, or modulo operator. +data MultiplicativeOperator = + MultiplicativeOperatorTimes | + MultiplicativeOperatorDivide | + MultiplicativeOperatorModulo + deriving (Eq, Ord, Read, Show) + +_MultiplicativeOperator = Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator" + +_MultiplicativeOperator_times = Model.Name "times" + +_MultiplicativeOperator_divide = Model.Name "divide" + +_MultiplicativeOperator_modulo = Model.Name "modulo" + +-- | An argument of the form 'name: value' passed to an attribute constructor. +data NamedArgument = + NamedArgument { + namedArgumentName :: Identifier, + namedArgumentValue :: AttributeArgumentExpression} + deriving (Eq, Ord, Read, Show) + +_NamedArgument = Model.Name "hydra.ext.csharp.syntax.NamedArgument" + +_NamedArgument_name = Model.Name "name" + +_NamedArgument_value = Model.Name "value" + +-- | A non-empty, comma-separated list of named arguments passed to an attribute. +newtype NamedArgumentList = + NamedArgumentList { + unNamedArgumentList :: [NamedArgument]} + deriving (Eq, Ord, Read, Show) + +_NamedArgumentList = Model.Name "hydra.ext.csharp.syntax.NamedArgumentList" + +-- | The target expression of a 'nameof' operator, with its chain of accessed parts. +data NamedEntity = + NamedEntity { + namedEntityTarget :: NamedEntityTarget, + namedEntityParts :: [NamedEntityPart]} + deriving (Eq, Ord, Read, Show) + +_NamedEntity = Model.Name "hydra.ext.csharp.syntax.NamedEntity" + +_NamedEntity_target = Model.Name "target" + +_NamedEntity_parts = Model.Name "parts" + +-- | A single '.identifier' segment chained within a named entity. +data NamedEntityPart = + NamedEntityPart { + namedEntityPartIdentifier :: Identifier, + namedEntityPartTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_NamedEntityPart = Model.Name "hydra.ext.csharp.syntax.NamedEntityPart" + +_NamedEntityPart_identifier = Model.Name "identifier" + +_NamedEntityPart_typeArguments = Model.Name "typeArguments" + +-- | The initial target of a named entity: a simple name, this, base, or a predefined/aliased type. +data NamedEntityTarget = + NamedEntityTargetName SimpleName | + NamedEntityTargetThis | + NamedEntityTargetBase | + NamedEntityTargetPredefinedType PredefinedType | + NamedEntityTargetQualifiedAliasMember QualifiedAliasMember + deriving (Eq, Ord, Read, Show) + +_NamedEntityTarget = Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget" + +_NamedEntityTarget_name = Model.Name "name" + +_NamedEntityTarget_this = Model.Name "this" + +_NamedEntityTarget_base = Model.Name "base" + +_NamedEntityTarget_predefinedType = Model.Name "predefinedType" + +_NamedEntityTarget_qualifiedAliasMember = Model.Name "qualifiedAliasMember" + +-- | The extern aliases, using directives, and member declarations within a namespace. +data NamespaceBody = + NamespaceBody { + namespaceBodyExterns :: [ExternAliasDirective], + namespaceBodyUsings :: [UsingDirective], + namespaceBodyMembers :: [NamespaceMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_NamespaceBody = Model.Name "hydra.ext.csharp.syntax.NamespaceBody" + +_NamespaceBody_externs = Model.Name "externs" + +_NamespaceBody_usings = Model.Name "usings" + +_NamespaceBody_members = Model.Name "members" + +-- | A namespace declaration, naming the namespace and giving its body. +data NamespaceDeclaration = + NamespaceDeclaration { + namespaceDeclarationName :: QualifiedIdentifier, + namespaceDeclarationBody :: NamespaceBody} + deriving (Eq, Ord, Read, Show) + +_NamespaceDeclaration = Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration" + +_NamespaceDeclaration_name = Model.Name "name" + +_NamespaceDeclaration_body = Model.Name "body" + +-- | A member of a namespace: a nested namespace declaration or a type declaration. +data NamespaceMemberDeclaration = + NamespaceMemberDeclarationNamespace NamespaceDeclaration | + NamespaceMemberDeclarationType TypeDeclaration + deriving (Eq, Ord, Read, Show) + +_NamespaceMemberDeclaration = Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration" + +_NamespaceMemberDeclaration_namespace = Model.Name "namespace" + +_NamespaceMemberDeclaration_type = Model.Name "type" + +-- | A reference to a namespace, expressed as a namespace-or-type name. +newtype NamespaceName = + NamespaceName { + unNamespaceName :: NamespaceOrTypeName} + deriving (Eq, Ord, Read, Show) + +_NamespaceName = Model.Name "hydra.ext.csharp.syntax.NamespaceName" + +-- | A name that may refer to either a namespace or a type: identifier, qualified, or alias-qualified. +data NamespaceOrTypeName = + NamespaceOrTypeNameIdentifier IdentifierNamespaceOrTypeName | + NamespaceOrTypeNameQualified QualifiedNamespaceOrTypeName | + NamespaceOrTypeNameAlias QualifiedAliasMember + deriving (Eq, Ord, Read, Show) + +_NamespaceOrTypeName = Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName" + +_NamespaceOrTypeName_identifier = Model.Name "identifier" + +_NamespaceOrTypeName_qualified = Model.Name "qualified" + +_NamespaceOrTypeName_alias = Model.Name "alias" + +-- | A type that is not itself an array type: value, class, interface, delegate, dynamic, or pointer. +data NonArrayType = + NonArrayTypeValue ValueType | + NonArrayTypeClass ClassType | + NonArrayTypeInterface InterfaceType | + NonArrayTypeDelegate DelegateType | + NonArrayTypeDynamic | + NonArrayTypeParameter TypeParameter | + NonArrayTypePointer PointerType + deriving (Eq, Ord, Read, Show) + +_NonArrayType = Model.Name "hydra.ext.csharp.syntax.NonArrayType" + +_NonArrayType_value = Model.Name "value" + +_NonArrayType_class = Model.Name "class" + +_NonArrayType_interface = Model.Name "interface" + +_NonArrayType_delegate = Model.Name "delegate" + +_NonArrayType_dynamic = Model.Name "dynamic" + +_NonArrayType_parameter = Model.Name "parameter" + +_NonArrayType_pointer = Model.Name "pointer" + +-- | Array creation giving the element type, dimension expressions, and rank specifiers directly. +data NonArrayTypeArrayCreationExpression = + NonArrayTypeArrayCreationExpression { + nonArrayTypeArrayCreationExpressionType :: NonArrayType, + nonArrayTypeArrayCreationExpressionExpressions :: ExpressionList, + nonArrayTypeArrayCreationExpressionRankSpecifiers :: [RankSpecifier], + nonArrayTypeArrayCreationExpressionInitializer :: (Maybe ArrayInitializer)} + deriving (Eq, Ord, Read, Show) + +_NonArrayTypeArrayCreationExpression = Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression" + +_NonArrayTypeArrayCreationExpression_type = Model.Name "type" + +_NonArrayTypeArrayCreationExpression_expressions = Model.Name "expressions" + +_NonArrayTypeArrayCreationExpression_rankSpecifiers = Model.Name "rankSpecifiers" + +_NonArrayTypeArrayCreationExpression_initializer = Model.Name "initializer" + +-- | An expression other than an assignment: declaration, conditional, lambda, or query expression. +data NonAssignmentExpression = + NonAssignmentExpressionDeclaration DeclarationExpression | + NonAssignmentExpressionConditional ConditionalExpression | + NonAssignmentExpressionLambda LambdaExpression | + NonAssignmentExpressionQuery QueryExpression + deriving (Eq, Ord, Read, Show) + +_NonAssignmentExpression = Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression" + +_NonAssignmentExpression_declaration = Model.Name "declaration" + +_NonAssignmentExpression_conditional = Model.Name "conditional" + +_NonAssignmentExpression_lambda = Model.Name "lambda" + +_NonAssignmentExpression_query = Model.Name "query" + +-- | A simple, binary (??), or throw-expression form of the null-coalescing operator. +data NullCoalescingExpression = + NullCoalescingExpressionSimple ConditionalOrExpression | + NullCoalescingExpressionBinary BinaryNullCoalescingExpression | + NullCoalescingExpressionThrow NullCoalescingExpression + deriving (Eq, Ord, Read, Show) + +_NullCoalescingExpression = Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression" + +_NullCoalescingExpression_simple = Model.Name "simple" + +_NullCoalescingExpression_binary = Model.Name "binary" + +_NullCoalescingExpression_throw = Model.Name "throw" + +-- | A null-conditional element access (?[...]) with its chain of dependent accesses. +data NullConditionalElementAccess = + NullConditionalElementAccess { + nullConditionalElementAccessExpression :: PrimaryNoArrayCreationExpression, + nullConditionalElementAccessArguments :: ArgumentList, + nullConditionalElementAccessDependentAccess :: [DependentAccess]} + deriving (Eq, Ord, Read, Show) + +_NullConditionalElementAccess = Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess" + +_NullConditionalElementAccess_expression = Model.Name "expression" + +_NullConditionalElementAccess_arguments = Model.Name "arguments" + +_NullConditionalElementAccess_dependentAccess = Model.Name "dependentAccess" + +-- | A null-conditional invocation (?.method(...) or ?[...]) with optional arguments. +data NullConditionalInvocationExpression = + NullConditionalInvocationExpression { + nullConditionalInvocationExpressionHead :: NullConditionalInvocationExpressionHead, + nullConditionalInvocationExpressionArguments :: (Maybe ArgumentList)} + deriving (Eq, Ord, Read, Show) + +_NullConditionalInvocationExpression = Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression" + +_NullConditionalInvocationExpression_head = Model.Name "head" + +_NullConditionalInvocationExpression_arguments = Model.Name "arguments" + +-- | The member- or element-access head of a null-conditional invocation expression. +data NullConditionalInvocationExpressionHead = + NullConditionalInvocationExpressionHeadMember NullConditionalMemberAccess | + NullConditionalInvocationExpressionHeadElement NullConditionalElementAccess + deriving (Eq, Ord, Read, Show) + +_NullConditionalInvocationExpressionHead = Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead" + +_NullConditionalInvocationExpressionHead_member = Model.Name "member" + +_NullConditionalInvocationExpressionHead_element = Model.Name "element" + +-- | A null-conditional member access (?.member) with its chain of dependent accesses. +data NullConditionalMemberAccess = + NullConditionalMemberAccess { + nullConditionalMemberAccessExpression :: PrimaryExpression, + nullConditionalMemberAccessIdentifier :: Identifier, + nullConditionalMemberAccessTypeArguments :: (Maybe TypeArgumentList), + nullConditionalMemberAccessDependentAccess :: [DependentAccess]} + deriving (Eq, Ord, Read, Show) + +_NullConditionalMemberAccess = Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess" + +_NullConditionalMemberAccess_expression = Model.Name "expression" + +_NullConditionalMemberAccess_identifier = Model.Name "identifier" + +_NullConditionalMemberAccess_typeArguments = Model.Name "typeArguments" + +_NullConditionalMemberAccess_dependentAccess = Model.Name "dependentAccess" + +-- | A null-conditional member projection used inside an anonymous object initializer. +data NullConditionalProjectionInitializer = + NullConditionalProjectionInitializer { + nullConditionalProjectionInitializerExpression :: PrimaryExpression, + nullConditionalProjectionInitializerIdentifier :: Identifier, + nullConditionalProjectionInitializerTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_NullConditionalProjectionInitializer = Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer" + +_NullConditionalProjectionInitializer_expression = Model.Name "expression" + +_NullConditionalProjectionInitializer_identifier = Model.Name "identifier" + +_NullConditionalProjectionInitializer_typeArguments = Model.Name "typeArguments" + +-- | A numeric type: integral, floating-point, or decimal. +data NumericType = + NumericTypeIntegral IntegralType | + NumericTypeFloatingPoint FloatingPointType | + NumericTypeDecimal + deriving (Eq, Ord, Read, Show) + +_NumericType = Model.Name "hydra.ext.csharp.syntax.NumericType" + +_NumericType_integral = Model.Name "integral" + +_NumericType_floatingPoint = Model.Name "floatingPoint" + +_NumericType_decimal = Model.Name "decimal" + +-- | A 'new' expression that constructs an object, with optional arguments and initializer. +data ObjectCreationExpression = + ObjectCreationExpression { + objectCreationExpressionType :: Type, + objectCreationExpressionArguments :: (Maybe ArgumentList), + objectCreationExpressionInitializer :: (Maybe ObjectOrCollectionInitializer)} + deriving (Eq, Ord, Read, Show) + +_ObjectCreationExpression = Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression" + +_ObjectCreationExpression_type = Model.Name "type" + +_ObjectCreationExpression_arguments = Model.Name "arguments" + +_ObjectCreationExpression_initializer = Model.Name "initializer" + +-- | An object initializer's member list, or a collection initializer's element list. +data ObjectOrCollectionInitializer = + ObjectOrCollectionInitializerObject [MemberInitializer] | + ObjectOrCollectionInitializerCollection [ElementInitializer] + deriving (Eq, Ord, Read, Show) + +_ObjectOrCollectionInitializer = Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer" + +_ObjectOrCollectionInitializer_object = Model.Name "object" + +_ObjectOrCollectionInitializer_collection = Model.Name "collection" + +-- | The body of an operator overload declaration: a block, expression body, or empty (extern) body. +data OperatorBody = + OperatorBodyBlock Block | + OperatorBodyExpression Expression | + OperatorBodyEmpty + deriving (Eq, Ord, Read, Show) + +_OperatorBody = Model.Name "hydra.ext.csharp.syntax.OperatorBody" + +_OperatorBody_block = Model.Name "block" + +_OperatorBody_expression = Model.Name "expression" + +_OperatorBody_empty = Model.Name "empty" + +-- | A user-defined operator overload declaration, with its modifiers, declarator, and body. +data OperatorDeclaration = + OperatorDeclaration { + operatorDeclarationAttributes :: (Maybe Attributes), + operatorDeclarationModifiers :: [OperatorModifier], + operatorDeclarationDeclarator :: OperatorDeclarator, + operatorDeclarationBody :: OperatorBody} + deriving (Eq, Ord, Read, Show) + +_OperatorDeclaration = Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration" + +_OperatorDeclaration_attributes = Model.Name "attributes" + +_OperatorDeclaration_modifiers = Model.Name "modifiers" + +_OperatorDeclaration_declarator = Model.Name "declarator" + +_OperatorDeclaration_body = Model.Name "body" + +-- | The declarator of an operator overload: unary, binary, or conversion form. +data OperatorDeclarator = + OperatorDeclaratorUnary UnaryOperatorDeclarator | + OperatorDeclaratorBinary BinaryOperatorDeclarator | + OperatorDeclaratorConversion ConversionOperatorDeclarator + deriving (Eq, Ord, Read, Show) + +_OperatorDeclarator = Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator" + +_OperatorDeclarator_unary = Model.Name "unary" + +_OperatorDeclarator_binary = Model.Name "binary" + +_OperatorDeclarator_conversion = Model.Name "conversion" + +-- | A modifier keyword on an operator declaration: public, static, extern, or unsafe. +data OperatorModifier = + OperatorModifierPublic | + OperatorModifierStatic | + OperatorModifierExtern | + OperatorModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_OperatorModifier = Model.Name "hydra.ext.csharp.syntax.OperatorModifier" + +_OperatorModifier_public = Model.Name "public" + +_OperatorModifier_static = Model.Name "static" + +_OperatorModifier_extern = Model.Name "extern" + +_OperatorModifier_unsafe = Model.Name "unsafe" + +-- | A single ordering key expression, with an optional ascending/descending direction, in an orderby clause. +data Ordering = + Ordering { + orderingExpression :: Expression, + orderingDirection :: (Maybe OrderingDirection)} + deriving (Eq, Ord, Read, Show) + +_Ordering = Model.Name "hydra.ext.csharp.syntax.Ordering" + +_Ordering_expression = Model.Name "expression" + +_Ordering_direction = Model.Name "direction" + +-- | The ascending or descending direction of an ordering key in an orderby clause. +data OrderingDirection = + OrderingDirectionAscending | + OrderingDirectionDescending + deriving (Eq, Ord, Read, Show) + +_OrderingDirection = Model.Name "hydra.ext.csharp.syntax.OrderingDirection" + +_OrderingDirection_ascending = Model.Name "ascending" + +_OrderingDirection_descending = Model.Name "descending" + +-- | A binary operator symbol that may be overloaded via a user-defined operator declaration. +data OverloadableBinaryOperator = + OverloadableBinaryOperatorAdd | + OverloadableBinaryOperatorSubtract | + OverloadableBinaryOperatorMultiply | + OverloadableBinaryOperatorDivide | + OverloadableBinaryOperatorModulus | + OverloadableBinaryOperatorAnd | + OverloadableBinaryOperatorOr | + OverloadableBinaryOperatorXor | + OverloadableBinaryOperatorLeftShift | + OverloadableBinaryOperatorRightShift | + OverloadableBinaryOperatorEqual | + OverloadableBinaryOperatorNotEqual | + OverloadableBinaryOperatorGreaterThan | + OverloadableBinaryOperatorLessThan | + OverloadableBinaryOperatorGreaterThanOrEqual | + OverloadableBinaryOperatorLessThanOrEqual + deriving (Eq, Ord, Read, Show) + +_OverloadableBinaryOperator = Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator" + +_OverloadableBinaryOperator_add = Model.Name "add" + +_OverloadableBinaryOperator_subtract = Model.Name "subtract" + +_OverloadableBinaryOperator_multiply = Model.Name "multiply" + +_OverloadableBinaryOperator_divide = Model.Name "divide" + +_OverloadableBinaryOperator_modulus = Model.Name "modulus" + +_OverloadableBinaryOperator_and = Model.Name "and" + +_OverloadableBinaryOperator_or = Model.Name "or" + +_OverloadableBinaryOperator_xor = Model.Name "xor" + +_OverloadableBinaryOperator_leftShift = Model.Name "leftShift" + +_OverloadableBinaryOperator_rightShift = Model.Name "rightShift" + +_OverloadableBinaryOperator_equal = Model.Name "equal" + +_OverloadableBinaryOperator_notEqual = Model.Name "notEqual" + +_OverloadableBinaryOperator_greaterThan = Model.Name "greaterThan" + +_OverloadableBinaryOperator_lessThan = Model.Name "lessThan" + +_OverloadableBinaryOperator_greaterThanOrEqual = Model.Name "greaterThanOrEqual" + +_OverloadableBinaryOperator_lessThanOrEqual = Model.Name "lessThanOrEqual" + +-- | A unary operator symbol that may be overloaded via a user-defined operator declaration. +data OverloadableUnaryOperator = + OverloadableUnaryOperatorPlus | + OverloadableUnaryOperatorMinus | + OverloadableUnaryOperatorNot | + OverloadableUnaryOperatorComplement | + OverloadableUnaryOperatorIncrement | + OverloadableUnaryOperatorDecrement | + OverloadableUnaryOperatorTrue | + OverloadableUnaryOperatorFalse + deriving (Eq, Ord, Read, Show) + +_OverloadableUnaryOperator = Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator" + +_OverloadableUnaryOperator_plus = Model.Name "plus" + +_OverloadableUnaryOperator_minus = Model.Name "minus" + +_OverloadableUnaryOperator_not = Model.Name "not" + +_OverloadableUnaryOperator_complement = Model.Name "complement" + +_OverloadableUnaryOperator_increment = Model.Name "increment" + +_OverloadableUnaryOperator_decrement = Model.Name "decrement" + +_OverloadableUnaryOperator_true = Model.Name "true" + +_OverloadableUnaryOperator_false = Model.Name "false" + +-- | A trailing 'params' array parameter of a formal parameter list. +data ParameterArray = + ParameterArray { + parameterArrayAttributes :: (Maybe Attributes), + parameterArrayType :: ArrayType, + parameterArrayIdentifier :: Identifier} + deriving (Eq, Ord, Read, Show) + +_ParameterArray = Model.Name "hydra.ext.csharp.syntax.ParameterArray" + +_ParameterArray_attributes = Model.Name "attributes" + +_ParameterArray_type = Model.Name "type" + +_ParameterArray_identifier = Model.Name "identifier" + +-- | The ref, out, or in passing-mode modifier on a fixed parameter. +data ParameterModeModifier = + ParameterModeModifierRef | + ParameterModeModifierOut | + ParameterModeModifierIn + deriving (Eq, Ord, Read, Show) + +_ParameterModeModifier = Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier" + +_ParameterModeModifier_ref = Model.Name "ref" + +_ParameterModeModifier_out = Model.Name "out" + +_ParameterModeModifier_in = Model.Name "in" + +-- | A modifier on a fixed parameter: a passing-mode modifier, or 'this' for extension methods. +data ParameterModifier = + ParameterModifierMode ParameterModeModifier | + ParameterModifierThis + deriving (Eq, Ord, Read, Show) + +_ParameterModifier = Model.Name "hydra.ext.csharp.syntax.ParameterModifier" + +_ParameterModifier_mode = Model.Name "mode" + +_ParameterModifier_this = Model.Name "this" + +-- | A pattern used in pattern matching: a declaration, constant, or var pattern. +data Pattern = + PatternDeclaration DeclarationPattern | + PatternConstant Expression | + PatternVar Designation + deriving (Eq, Ord, Read, Show) + +_Pattern = Model.Name "hydra.ext.csharp.syntax.Pattern" + +_Pattern_declaration = Model.Name "declaration" + +_Pattern_constant = Model.Name "constant" + +_Pattern_var = Model.Name "var" + +-- | An unsafe pointer indexing expression (pointer[index]). +data PointerElementAccess = + PointerElementAccess { + pointerElementAccessPointer :: PrimaryNoArrayCreationExpression, + pointerElementAccessIndex :: Expression} + deriving (Eq, Ord, Read, Show) + +_PointerElementAccess = Model.Name "hydra.ext.csharp.syntax.PointerElementAccess" + +_PointerElementAccess_pointer = Model.Name "pointer" + +_PointerElementAccess_index = Model.Name "index" + +-- | An unsafe pointer member access expression (pointer->member). +data PointerMemberAccess = + PointerMemberAccess { + pointerMemberAccessPointer :: PrimaryExpression, + pointerMemberAccessMember :: Identifier, + pointerMemberAccessTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_PointerMemberAccess = Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess" + +_PointerMemberAccess_pointer = Model.Name "pointer" + +_PointerMemberAccess_member = Model.Name "member" + +_PointerMemberAccess_typeArguments = Model.Name "typeArguments" + +-- | An unsafe pointer type, formed from a pointee value type and a pointer depth. +data PointerType = + PointerTypeValueType (Maybe ValueType) | + PointerTypePointerDepth Int + deriving (Eq, Ord, Read, Show) + +_PointerType = Model.Name "hydra.ext.csharp.syntax.PointerType" + +_PointerType_valueType = Model.Name "valueType" + +_PointerType_pointerDepth = Model.Name "pointerDepth" + +-- | A single positional (or optionally named) argument in an attribute's argument list. +data PositionalArgument = + PositionalArgument { + positionalArgumentName :: (Maybe Identifier), + positionalArgumentValue :: AttributeArgumentExpression} + deriving (Eq, Ord, Read, Show) + +_PositionalArgument = Model.Name "hydra.ext.csharp.syntax.PositionalArgument" + +_PositionalArgument_name = Model.Name "name" + +_PositionalArgument_value = Model.Name "value" + +-- | A non-empty, comma-separated list of positional arguments passed to an attribute. +newtype PositionalArgumentList = + PositionalArgumentList { + unPositionalArgumentList :: [PositionalArgument]} + deriving (Eq, Ord, Read, Show) + +_PositionalArgumentList = Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList" + +-- | One of the built-in predefined type keywords, such as int, string, or bool. +data PredefinedType = + PredefinedTypeBool | + PredefinedTypeByte | + PredefinedTypeChar | + PredefinedTypeDecimal | + PredefinedTypeDouble | + PredefinedTypeFloat | + PredefinedTypeInt | + PredefinedTypeLong | + PredefinedTypeObject | + PredefinedTypeSbyte | + PredefinedTypeShort | + PredefinedTypeString | + PredefinedTypeUint | + PredefinedTypeUlong | + PredefinedTypeUshort + deriving (Eq, Ord, Read, Show) + +_PredefinedType = Model.Name "hydra.ext.csharp.syntax.PredefinedType" + +_PredefinedType_bool = Model.Name "bool" + +_PredefinedType_byte = Model.Name "byte" + +_PredefinedType_char = Model.Name "char" + +_PredefinedType_decimal = Model.Name "decimal" + +_PredefinedType_double = Model.Name "double" + +_PredefinedType_float = Model.Name "float" + +_PredefinedType_int = Model.Name "int" + +_PredefinedType_long = Model.Name "long" + +_PredefinedType_object = Model.Name "object" + +_PredefinedType_sbyte = Model.Name "sbyte" + +_PredefinedType_short = Model.Name "short" + +_PredefinedType_string = Model.Name "string" + +_PredefinedType_uint = Model.Name "uint" + +_PredefinedType_ulong = Model.Name "ulong" + +_PredefinedType_ushort = Model.Name "ushort" + +-- | The primary type-parameter constraint: a class type, or the class/struct/unmanaged constraint. +data PrimaryConstraint = + PrimaryConstraintClassType ClassType | + PrimaryConstraintClass | + PrimaryConstraintStruct | + PrimaryConstraintUnmanaged + deriving (Eq, Ord, Read, Show) + +_PrimaryConstraint = Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint" + +_PrimaryConstraint_classType = Model.Name "classType" + +_PrimaryConstraint_class = Model.Name "class" + +_PrimaryConstraint_struct = Model.Name "struct" + +_PrimaryConstraint_unmanaged = Model.Name "unmanaged" + +-- | An expression without an array creation, or an array creation expression. +data PrimaryExpression = + PrimaryExpressionNoArray PrimaryNoArrayCreationExpression | + PrimaryExpressionArray ArrayCreationExpression + deriving (Eq, Ord, Read, Show) + +_PrimaryExpression = Model.Name "hydra.ext.csharp.syntax.PrimaryExpression" + +_PrimaryExpression_noArray = Model.Name "noArray" + +_PrimaryExpression_array = Model.Name "array" + +-- | A primary expression other than array creation: literal, invocation, access, and so on. +data PrimaryNoArrayCreationExpression = + PrimaryNoArrayCreationExpressionLiteral Literal | + PrimaryNoArrayCreationExpressionInterpolatedString InterpolatedStringExpression | + PrimaryNoArrayCreationExpressionSimpleName SimpleName | + PrimaryNoArrayCreationExpressionParenthesized Expression | + PrimaryNoArrayCreationExpressionTuple TupleExpression | + PrimaryNoArrayCreationExpressionMemberAccess MemberAccess | + PrimaryNoArrayCreationExpressionNullConditionalMemberAccess NullConditionalMemberAccess | + PrimaryNoArrayCreationExpressionInvocation InvocationExpression | + PrimaryNoArrayCreationExpressionElementAccess ElementAccess | + PrimaryNoArrayCreationExpressionNullConditionalElementAccess NullConditionalElementAccess | + PrimaryNoArrayCreationExpressionThisAccess | + PrimaryNoArrayCreationExpressionBaseAccess BaseAccess | + PrimaryNoArrayCreationExpressionPostIncrement PrimaryExpression | + PrimaryNoArrayCreationExpressionPostDecrement PrimaryExpression | + PrimaryNoArrayCreationExpressionObjectCreation ObjectCreationExpression | + PrimaryNoArrayCreationExpressionDelegateCreation DelegateCreationExpression | + PrimaryNoArrayCreationExpressionAnonymousObjectCreation (Maybe MemberDeclaratorList) | + PrimaryNoArrayCreationExpressionTypeof TypeofExpression | + PrimaryNoArrayCreationExpressionSizeof UnmanagedType | + PrimaryNoArrayCreationExpressionChecked Expression | + PrimaryNoArrayCreationExpressionUnchecked Expression | + PrimaryNoArrayCreationExpressionDefaultValue DefaultValueExpression | + PrimaryNoArrayCreationExpressionNameof NamedEntity | + PrimaryNoArrayCreationExpressionAnonymousMethod AnonymousMethodExpression | + PrimaryNoArrayCreationExpressionPointerMemberAccess PointerMemberAccess | + PrimaryNoArrayCreationExpressionPointerElementAccess PointerElementAccess | + PrimaryNoArrayCreationExpressionStackalloc StackallocExpression + deriving (Eq, Ord, Read, Show) + +_PrimaryNoArrayCreationExpression = Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression" + +_PrimaryNoArrayCreationExpression_literal = Model.Name "literal" + +_PrimaryNoArrayCreationExpression_interpolatedString = Model.Name "interpolatedString" + +_PrimaryNoArrayCreationExpression_simpleName = Model.Name "simpleName" + +_PrimaryNoArrayCreationExpression_parenthesized = Model.Name "parenthesized" + +_PrimaryNoArrayCreationExpression_tuple = Model.Name "tuple" + +_PrimaryNoArrayCreationExpression_memberAccess = Model.Name "memberAccess" + +_PrimaryNoArrayCreationExpression_nullConditionalMemberAccess = Model.Name "nullConditionalMemberAccess" + +_PrimaryNoArrayCreationExpression_invocation = Model.Name "invocation" + +_PrimaryNoArrayCreationExpression_elementAccess = Model.Name "elementAccess" + +_PrimaryNoArrayCreationExpression_nullConditionalElementAccess = Model.Name "nullConditionalElementAccess" + +_PrimaryNoArrayCreationExpression_thisAccess = Model.Name "thisAccess" + +_PrimaryNoArrayCreationExpression_baseAccess = Model.Name "baseAccess" + +_PrimaryNoArrayCreationExpression_postIncrement = Model.Name "postIncrement" + +_PrimaryNoArrayCreationExpression_postDecrement = Model.Name "postDecrement" + +_PrimaryNoArrayCreationExpression_objectCreation = Model.Name "objectCreation" + +_PrimaryNoArrayCreationExpression_delegateCreation = Model.Name "delegateCreation" + +_PrimaryNoArrayCreationExpression_anonymousObjectCreation = Model.Name "anonymousObjectCreation" + +_PrimaryNoArrayCreationExpression_typeof = Model.Name "typeof" + +_PrimaryNoArrayCreationExpression_sizeof = Model.Name "sizeof" + +_PrimaryNoArrayCreationExpression_checked = Model.Name "checked" + +_PrimaryNoArrayCreationExpression_unchecked = Model.Name "unchecked" + +_PrimaryNoArrayCreationExpression_defaultValue = Model.Name "defaultValue" + +_PrimaryNoArrayCreationExpression_nameof = Model.Name "nameof" + +_PrimaryNoArrayCreationExpression_anonymousMethod = Model.Name "anonymousMethod" + +_PrimaryNoArrayCreationExpression_pointerMemberAccess = Model.Name "pointerMemberAccess" + +_PrimaryNoArrayCreationExpression_pointerElementAccess = Model.Name "pointerElementAccess" + +_PrimaryNoArrayCreationExpression_stackalloc = Model.Name "stackalloc" + +-- | The body of a standard property: block accessors or a single expression body. +data PropertyBody = + PropertyBodyBlock BlockPropertyBody | + PropertyBodyExpression Expression + deriving (Eq, Ord, Read, Show) + +_PropertyBody = Model.Name "hydra.ext.csharp.syntax.PropertyBody" + +_PropertyBody_block = Model.Name "block" + +_PropertyBody_expression = Model.Name "expression" + +-- | A property member declaration, in its standard or ref-returning form. +data PropertyDeclaration = + PropertyDeclarationStandard StandardPropertyDeclaration | + PropertyDeclarationRefReturn RefReturnPropertyDeclaration + deriving (Eq, Ord, Read, Show) + +_PropertyDeclaration = Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration" + +_PropertyDeclaration_standard = Model.Name "standard" + +_PropertyDeclaration_refReturn = Model.Name "refReturn" + +-- | A modifier keyword on a property declaration, such as virtual, override, or abstract. +data PropertyModifier = + PropertyModifierNew | + PropertyModifierPublic | + PropertyModifierProtected | + PropertyModifierInternal | + PropertyModifierPrivate | + PropertyModifierStatic | + PropertyModifierVirtual | + PropertyModifierSealed | + PropertyModifierOverride | + PropertyModifierAbstract | + PropertyModifierExtern | + PropertyModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_PropertyModifier = Model.Name "hydra.ext.csharp.syntax.PropertyModifier" + +_PropertyModifier_new = Model.Name "new" + +_PropertyModifier_public = Model.Name "public" + +_PropertyModifier_protected = Model.Name "protected" + +_PropertyModifier_internal = Model.Name "internal" + +_PropertyModifier_private = Model.Name "private" + +_PropertyModifier_static = Model.Name "static" + +_PropertyModifier_virtual = Model.Name "virtual" + +_PropertyModifier_sealed = Model.Name "sealed" + +_PropertyModifier_override = Model.Name "override" + +_PropertyModifier_abstract = Model.Name "abstract" + +_PropertyModifier_extern = Model.Name "extern" + +_PropertyModifier_unsafe = Model.Name "unsafe" + +-- | An 'alias::member' reference, with optional type arguments, using an extern or global alias. +data QualifiedAliasMember = + QualifiedAliasMember { + qualifiedAliasMemberAlias :: Identifier, + qualifiedAliasMemberMember :: Identifier, + qualifiedAliasMemberArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_QualifiedAliasMember = Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember" + +_QualifiedAliasMember_alias = Model.Name "alias" + +_QualifiedAliasMember_member = Model.Name "member" + +_QualifiedAliasMember_arguments = Model.Name "arguments" + +-- | A non-empty, dot-separated sequence of identifiers, as used in a namespace declaration. +newtype QualifiedIdentifier = + QualifiedIdentifier { + unQualifiedIdentifier :: [Identifier]} + deriving (Eq, Ord, Read, Show) + +_QualifiedIdentifier = Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier" + +-- | A namespace-or-type name qualified with a preceding namespace-or-type and identifier. +data QualifiedNamespaceOrTypeName = + QualifiedNamespaceOrTypeName { + qualifiedNamespaceOrTypeNameNamespaceOrType :: NamespaceOrTypeName, + qualifiedNamespaceOrTypeNameIdentifier :: Identifier, + qualifiedNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_QualifiedNamespaceOrTypeName = Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName" + +_QualifiedNamespaceOrTypeName_namespaceOrType = Model.Name "namespaceOrType" + +_QualifiedNamespaceOrTypeName_identifier = Model.Name "identifier" + +_QualifiedNamespaceOrTypeName_arguments = Model.Name "arguments" + +-- | The clauses, select/group clause, and optional continuation of a query expression. +data QueryBody = + QueryBody { + queryBodyClauses :: [QueryBodyClause], + queryBodySelectOrGroup :: SelectOrGroupClause, + queryBodyContinuation :: (Maybe QueryContinuation)} + deriving (Eq, Ord, Read, Show) + +_QueryBody = Model.Name "hydra.ext.csharp.syntax.QueryBody" + +_QueryBody_clauses = Model.Name "clauses" + +_QueryBody_selectOrGroup = Model.Name "selectOrGroup" + +_QueryBody_continuation = Model.Name "continuation" + +-- | A clause in a query expression body: from, let, where, join, or orderby. +data QueryBodyClause = + QueryBodyClauseFrom FromClause | + QueryBodyClauseLet LetClause | + QueryBodyClauseWhere BooleanExpression | + QueryBodyClauseJoin JoinClause | + QueryBodyClauseOrderby [Ordering] + deriving (Eq, Ord, Read, Show) + +_QueryBodyClause = Model.Name "hydra.ext.csharp.syntax.QueryBodyClause" + +_QueryBodyClause_from = Model.Name "from" + +_QueryBodyClause_let = Model.Name "let" + +_QueryBodyClause_where = Model.Name "where" + +_QueryBodyClause_join = Model.Name "join" + +_QueryBodyClause_orderby = Model.Name "orderby" + +-- | An 'into' continuation that feeds a query's results into a further query body. +data QueryContinuation = + QueryContinuation { + queryContinuationInto :: Identifier, + queryContinuationBody :: QueryBody} + deriving (Eq, Ord, Read, Show) + +_QueryContinuation = Model.Name "hydra.ext.csharp.syntax.QueryContinuation" + +_QueryContinuation_into = Model.Name "into" + +_QueryContinuation_body = Model.Name "body" + +-- | A LINQ query expression, starting with a from clause and continuing with a query body. +data QueryExpression = + QueryExpression { + queryExpressionFrom :: FromClause, + queryExpressionBody :: QueryBody} + deriving (Eq, Ord, Read, Show) + +_QueryExpression = Model.Name "hydra.ext.csharp.syntax.QueryExpression" + +_QueryExpression_from = Model.Name "from" + +_QueryExpression_body = Model.Name "body" + +-- | The rank (number of dimensions) of an array type or array creation expression. +newtype RankSpecifier = + RankSpecifier { + unRankSpecifier :: Int} + deriving (Eq, Ord, Read, Show) + +_RankSpecifier = Model.Name "hydra.ext.csharp.syntax.RankSpecifier" + +-- | Array creation using a rank specifier together with an array initializer, with inferred element type. +data RankSpecifierArrayCreationExpression = + RankSpecifierArrayCreationExpression { + rankSpecifierArrayCreationExpressionRankSpecifier :: RankSpecifier, + rankSpecifierArrayCreationExpressionInitializer :: ArrayInitializer} + deriving (Eq, Ord, Read, Show) + +_RankSpecifierArrayCreationExpression = Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression" + +_RankSpecifierArrayCreationExpression_rankSpecifier = Model.Name "rankSpecifier" + +_RankSpecifierArrayCreationExpression_initializer = Model.Name "initializer" + +-- | The body of a ref-returning get accessor: a block, ref expression, or empty (abstract) body. +data RefAccessorBody = + RefAccessorBodyBlock Block | + RefAccessorBodyRef VariableReference | + RefAccessorBodyEmpty + deriving (Eq, Ord, Read, Show) + +_RefAccessorBody = Model.Name "hydra.ext.csharp.syntax.RefAccessorBody" + +_RefAccessorBody_block = Model.Name "block" + +_RefAccessorBody_ref = Model.Name "ref" + +_RefAccessorBody_empty = Model.Name "empty" + +-- | A ref-returning conditional expression, selecting between two variable references. +data RefConditionalExpression = + RefConditionalExpression { + refConditionalExpressionCondition :: NullCoalescingExpression, + refConditionalExpressionTrue :: VariableReference, + refConditionalExpressionFalse :: VariableReference} + deriving (Eq, Ord, Read, Show) + +_RefConditionalExpression = Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression" + +_RefConditionalExpression_condition = Model.Name "condition" + +_RefConditionalExpression_true = Model.Name "true" + +_RefConditionalExpression_false = Model.Name "false" + +-- | A ref-returning property or indexer get accessor declaration. +data RefGetAccessorDeclaration = + RefGetAccessorDeclaration { + refGetAccessorDeclarationAttributes :: (Maybe Attributes), + refGetAccessorDeclarationModifier :: (Maybe AccessorModifier), + refGetAccessorDeclarationBody :: RefAccessorBody} + deriving (Eq, Ord, Read, Show) + +_RefGetAccessorDeclaration = Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration" + +_RefGetAccessorDeclaration_attributes = Model.Name "attributes" + +_RefGetAccessorDeclaration_modifier = Model.Name "modifier" + +_RefGetAccessorDeclaration_body = Model.Name "body" + +-- | The body of a ref-returning indexer: a ref get accessor, or a single ref expression. +data RefIndexerBody = + RefIndexerBodyBlock RefGetAccessorDeclaration | + RefIndexerBodyRef VariableReference + deriving (Eq, Ord, Read, Show) + +_RefIndexerBody = Model.Name "hydra.ext.csharp.syntax.RefIndexerBody" + +_RefIndexerBody_block = Model.Name "block" + +_RefIndexerBody_ref = Model.Name "ref" + +-- | A ref-returning indexer member declaration. +data RefIndexerDeclaration = + RefIndexerDeclaration { + refIndexerDeclarationAttributes :: (Maybe Attributes), + refIndexerDeclarationModifiers :: [IndexerModifier], + refIndexerDeclarationRefKind :: RefKind, + refIndexerDeclarationDeclarator :: IndexerDeclarator, + refIndexerDeclarationBody :: RefIndexerBody} + deriving (Eq, Ord, Read, Show) + +_RefIndexerDeclaration = Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration" + +_RefIndexerDeclaration_attributes = Model.Name "attributes" + +_RefIndexerDeclaration_modifiers = Model.Name "modifiers" + +_RefIndexerDeclaration_refKind = Model.Name "refKind" + +_RefIndexerDeclaration_declarator = Model.Name "declarator" + +_RefIndexerDeclaration_body = Model.Name "body" + +-- | Whether a ref-returning member returns by plain ref or by ref readonly. +data RefKind = + RefKindRef | + RefKindRefReadonly + deriving (Eq, Ord, Read, Show) + +_RefKind = Model.Name "hydra.ext.csharp.syntax.RefKind" + +_RefKind_ref = Model.Name "ref" + +_RefKind_refReadonly = Model.Name "refReadonly" + +-- | The body of a ref-returning local function: a block, or a single ref expression. +data RefLocalFunctionBody = + RefLocalFunctionBodyBlock Block | + RefLocalFunctionBodyRef VariableReference + deriving (Eq, Ord, Read, Show) + +_RefLocalFunctionBody = Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody" + +_RefLocalFunctionBody_block = Model.Name "block" + +_RefLocalFunctionBody_ref = Model.Name "ref" + +-- | A ref-returning local function declaration. +data RefLocalFunctionDeclaration = + RefLocalFunctionDeclaration { + refLocalFunctionDeclarationModifiers :: [RefLocalFunctionModifier], + refLocalFunctionDeclarationRefKind :: RefKind, + refLocalFunctionDeclarationReturnType :: Type, + refLocalFunctionDeclarationHeader :: LocalFunctionHeader, + refLocalFunctionDeclarationBody :: RefLocalFunctionBody} + deriving (Eq, Ord, Read, Show) + +_RefLocalFunctionDeclaration = Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration" + +_RefLocalFunctionDeclaration_modifiers = Model.Name "modifiers" + +_RefLocalFunctionDeclaration_refKind = Model.Name "refKind" + +_RefLocalFunctionDeclaration_returnType = Model.Name "returnType" + +_RefLocalFunctionDeclaration_header = Model.Name "header" + +_RefLocalFunctionDeclaration_body = Model.Name "body" + +-- | A modifier on a ref-returning local function declaration: static or unsafe. +data RefLocalFunctionModifier = + RefLocalFunctionModifierStatic | + RefLocalFunctionModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_RefLocalFunctionModifier = Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier" + +_RefLocalFunctionModifier_static = Model.Name "static" + +_RefLocalFunctionModifier_unsafe = Model.Name "unsafe" + +-- | A local variable declaration that binds a variable by reference. +data RefLocalVariableDeclaration = + RefLocalVariableDeclaration { + refLocalVariableDeclarationRefKind :: RefKind, + refLocalVariableDeclarationType :: Type, + refLocalVariableDeclarationDeclarators :: [RefLocalVariableDeclarator]} + deriving (Eq, Ord, Read, Show) + +_RefLocalVariableDeclaration = Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration" + +_RefLocalVariableDeclaration_refKind = Model.Name "refKind" + +_RefLocalVariableDeclaration_type = Model.Name "type" + +_RefLocalVariableDeclaration_declarators = Model.Name "declarators" + +-- | The identifier and referenced variable in a single ref local variable declarator. +data RefLocalVariableDeclarator = + RefLocalVariableDeclarator { + refLocalVariableDeclaratorLeft :: Identifier, + refLocalVariableDeclaratorRight :: VariableReference} + deriving (Eq, Ord, Read, Show) + +_RefLocalVariableDeclarator = Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator" + +_RefLocalVariableDeclarator_left = Model.Name "left" + +_RefLocalVariableDeclarator_right = Model.Name "right" + +-- | The body of a ref-returning method: a block, ref expression, or empty (extern) body. +data RefMethodBody = + RefMethodBodyBlock Block | + RefMethodBodyRef VariableReference | + RefMethodBodyEmpty + deriving (Eq, Ord, Read, Show) + +_RefMethodBody = Model.Name "hydra.ext.csharp.syntax.RefMethodBody" + +_RefMethodBody_block = Model.Name "block" + +_RefMethodBody_ref = Model.Name "ref" + +_RefMethodBody_empty = Model.Name "empty" + +-- | A modifier keyword on a ref-returning method declaration. +data RefMethodModifier = + RefMethodModifierNew | + RefMethodModifierPublic | + RefMethodModifierProtected | + RefMethodModifierInternal | + RefMethodModifierPrivate | + RefMethodModifierStatic | + RefMethodModifierVirtual | + RefMethodModifierSealed | + RefMethodModifierOverride | + RefMethodModifierAbstract | + RefMethodModifierExtern | + RefMethodModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_RefMethodModifier = Model.Name "hydra.ext.csharp.syntax.RefMethodModifier" + +_RefMethodModifier_new = Model.Name "new" + +_RefMethodModifier_public = Model.Name "public" + +_RefMethodModifier_protected = Model.Name "protected" + +_RefMethodModifier_internal = Model.Name "internal" + +_RefMethodModifier_private = Model.Name "private" + +_RefMethodModifier_static = Model.Name "static" + +_RefMethodModifier_virtual = Model.Name "virtual" + +_RefMethodModifier_sealed = Model.Name "sealed" + +_RefMethodModifier_override = Model.Name "override" + +_RefMethodModifier_abstract = Model.Name "abstract" + +_RefMethodModifier_extern = Model.Name "extern" + +_RefMethodModifier_unsafe = Model.Name "unsafe" + +-- | The body of a ref-returning property: a ref get accessor, or a single ref expression. +data RefPropertyBody = + RefPropertyBodyBlock RefGetAccessorDeclaration | + RefPropertyBodyRef VariableReference + deriving (Eq, Ord, Read, Show) + +_RefPropertyBody = Model.Name "hydra.ext.csharp.syntax.RefPropertyBody" + +_RefPropertyBody_block = Model.Name "block" + +_RefPropertyBody_ref = Model.Name "ref" + +-- | A ref-returning method declaration, including its ref kind, header, and body. +data RefReturnMethodDeclaration = + RefReturnMethodDeclaration { + refReturnMethodDeclarationAttributes :: (Maybe Attributes), + refReturnMethodDeclarationModifiers :: [RefMethodModifier], + refReturnMethodDeclarationKind :: RefKind, + refReturnMethodDeclarationReturnType :: ReturnType, + refReturnMethodDeclarationHeader :: MethodHeader, + refReturnMethodDeclarationBody :: RefMethodBody} + deriving (Eq, Ord, Read, Show) + +_RefReturnMethodDeclaration = Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration" + +_RefReturnMethodDeclaration_attributes = Model.Name "attributes" + +_RefReturnMethodDeclaration_modifiers = Model.Name "modifiers" + +_RefReturnMethodDeclaration_kind = Model.Name "kind" + +_RefReturnMethodDeclaration_returnType = Model.Name "returnType" + +_RefReturnMethodDeclaration_header = Model.Name "header" + +_RefReturnMethodDeclaration_body = Model.Name "body" + +-- | A ref-returning property declaration, including its ref kind and body. +data RefReturnPropertyDeclaration = + RefReturnPropertyDeclaration { + refReturnPropertyDeclarationAttributes :: (Maybe Attributes), + refReturnPropertyDeclarationModifiers :: [PropertyModifier], + refReturnPropertyDeclarationRefKind :: RefKind, + refReturnPropertyDeclarationType :: Type, + refReturnPropertyDeclarationName :: MemberName, + refReturnPropertyDeclarationBody :: RefPropertyBody} + deriving (Eq, Ord, Read, Show) + +_RefReturnPropertyDeclaration = Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration" + +_RefReturnPropertyDeclaration_attributes = Model.Name "attributes" + +_RefReturnPropertyDeclaration_modifiers = Model.Name "modifiers" + +_RefReturnPropertyDeclaration_refKind = Model.Name "refKind" + +_RefReturnPropertyDeclaration_type = Model.Name "type" + +_RefReturnPropertyDeclaration_name = Model.Name "name" + +_RefReturnPropertyDeclaration_body = Model.Name "body" + +-- | An implicitly typed local variable declared by reference using 'ref var'. +data RefVarImplicitlyTypedLocalVariableDeclaration = + RefVarImplicitlyTypedLocalVariableDeclaration { + refVarImplicitlyTypedLocalVariableDeclarationRefKind :: RefKind, + refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: RefLocalVariableDeclarator} + deriving (Eq, Ord, Read, Show) + +_RefVarImplicitlyTypedLocalVariableDeclaration = + Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration" + +_RefVarImplicitlyTypedLocalVariableDeclaration_refKind = Model.Name "refKind" + +_RefVarImplicitlyTypedLocalVariableDeclaration_declarator = Model.Name "declarator" + +-- | A reference type: class, interface, array, delegate, or the dynamic type. +data ReferenceType = + ReferenceTypeClass ClassType | + ReferenceTypeInterface InterfaceType | + ReferenceTypeArray ArrayType | + ReferenceTypeDelegate DelegateType | + ReferenceTypeDynamic + deriving (Eq, Ord, Read, Show) + +_ReferenceType = Model.Name "hydra.ext.csharp.syntax.ReferenceType" + +_ReferenceType_class = Model.Name "class" + +_ReferenceType_interface = Model.Name "interface" + +_ReferenceType_array = Model.Name "array" + +_ReferenceType_delegate = Model.Name "delegate" + +_ReferenceType_dynamic = Model.Name "dynamic" + +-- | A single '{expression[,width][:format]}' hole within a regular interpolated string. +data RegularInterpolation = + RegularInterpolation { + regularInterpolationExpression :: Expression, + regularInterpolationWidth :: (Maybe Expression), + regularInterpolationFormat :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_RegularInterpolation = Model.Name "hydra.ext.csharp.syntax.RegularInterpolation" + +_RegularInterpolation_expression = Model.Name "expression" + +_RegularInterpolation_width = Model.Name "width" + +_RegularInterpolation_format = Model.Name "format" + +-- | A simple, binary, is-type, is-pattern, or as-type relational expression. +data RelationalExpression = + RelationalExpressionSimple ShiftExpression | + RelationalExpressionBinary BinaryRelationalExpression | + RelationalExpressionIsType IsTypeExpression | + RelationalExpressionIsPattern IsPatternExpression | + RelationalExpressionAsType AsTypeExpression + deriving (Eq, Ord, Read, Show) + +_RelationalExpression = Model.Name "hydra.ext.csharp.syntax.RelationalExpression" + +_RelationalExpression_simple = Model.Name "simple" + +_RelationalExpression_binary = Model.Name "binary" + +_RelationalExpression_isType = Model.Name "isType" + +_RelationalExpression_isPattern = Model.Name "isPattern" + +_RelationalExpression_asType = Model.Name "asType" + +-- | A relational comparison operator: less than, greater than, or their or-equal variants. +data RelationalOperator = + RelationalOperatorLessThan | + RelationalOperatorGreaterThan | + RelationalOperatorLessThanOrEqual | + RelationalOperatorGreaterThanOrEqual + deriving (Eq, Ord, Read, Show) + +_RelationalOperator = Model.Name "hydra.ext.csharp.syntax.RelationalOperator" + +_RelationalOperator_lessThan = Model.Name "lessThan" + +_RelationalOperator_greaterThan = Model.Name "greaterThan" + +_RelationalOperator_lessThanOrEqual = Model.Name "lessThanOrEqual" + +_RelationalOperator_greaterThanOrEqual = Model.Name "greaterThanOrEqual" + +-- | The resource acquired by a using statement: a local variable declaration or an expression. +data ResourceAcquisition = + ResourceAcquisitionLocal LocalVariableDeclaration | + ResourceAcquisitionExpression Expression + deriving (Eq, Ord, Read, Show) + +_ResourceAcquisition = Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition" + +_ResourceAcquisition_local = Model.Name "local" + +_ResourceAcquisition_expression = Model.Name "expression" + +-- | A return statement, in its value-less, value-returning, or ref-returning form. +data ReturnStatement = + ReturnStatementSimple | + ReturnStatementValue Expression | + ReturnStatementRef VariableReference + deriving (Eq, Ord, Read, Show) + +_ReturnStatement = Model.Name "hydra.ext.csharp.syntax.ReturnStatement" + +_ReturnStatement_simple = Model.Name "simple" + +_ReturnStatement_value = Model.Name "value" + +_ReturnStatement_ref = Model.Name "ref" + +-- | The declared return type of a member: a ref-qualified type, or void. +data ReturnType = + ReturnTypeRef Type | + ReturnTypeVoid + deriving (Eq, Ord, Read, Show) + +_ReturnType = Model.Name "hydra.ext.csharp.syntax.ReturnType" + +_ReturnType_ref = Model.Name "ref" + +_ReturnType_void = Model.Name "void" + +-- | A secondary type-parameter constraint: an interface type or another type parameter. +data SecondaryConstraint = + SecondaryConstraintInterface InterfaceType | + SecondaryConstraintParameter TypeParameter + deriving (Eq, Ord, Read, Show) + +_SecondaryConstraint = Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint" + +_SecondaryConstraint_interface = Model.Name "interface" + +_SecondaryConstraint_parameter = Model.Name "parameter" + +-- | A non-empty list of secondary constraints on a type parameter. +newtype SecondaryConstraints = + SecondaryConstraints { + unSecondaryConstraints :: [SecondaryConstraint]} + deriving (Eq, Ord, Read, Show) + +_SecondaryConstraints = Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints" + +-- | The final clause of a query body: a 'select' projection or a 'group by' clause. +data SelectOrGroupClause = + SelectOrGroupClauseSelect Expression | + SelectOrGroupClauseGroup GroupClause + deriving (Eq, Ord, Read, Show) + +_SelectOrGroupClause = Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause" + +_SelectOrGroupClause_select = Model.Name "select" + +_SelectOrGroupClause_group = Model.Name "group" + +-- | An if or switch statement. +data SelectionStatement = + SelectionStatementIf IfStatement | + SelectionStatementSwitch SwitchStatement + deriving (Eq, Ord, Read, Show) + +_SelectionStatement = Model.Name "hydra.ext.csharp.syntax.SelectionStatement" + +_SelectionStatement_if = Model.Name "if" + +_SelectionStatement_switch = Model.Name "switch" + +-- | A simple additive expression or a binary left/right-shift expression. +data ShiftExpression = + ShiftExpressionSimple AdditiveExpression | + ShiftExpressionBinary BinaryShiftExpression + deriving (Eq, Ord, Read, Show) + +_ShiftExpression = Model.Name "hydra.ext.csharp.syntax.ShiftExpression" + +_ShiftExpression_simple = Model.Name "simple" + +_ShiftExpression_binary = Model.Name "binary" + +-- | The left-shift (<<) or right-shift (>>) operator. +data ShiftOperator = + ShiftOperatorLeft | + ShiftOperatorRight + deriving (Eq, Ord, Read, Show) + +_ShiftOperator = Model.Name "hydra.ext.csharp.syntax.ShiftOperator" + +_ShiftOperator_left = Model.Name "left" + +_ShiftOperator_right = Model.Name "right" + +-- | The ordinary ternary conditional expression: 'condition ? true : false'. +data SimpleConditionalExpression = + SimpleConditionalExpression { + simpleConditionalExpressionCondition :: NullCoalescingExpression, + simpleConditionalExpressionTrue :: Expression, + simpleConditionalExpressionFalse :: Expression} + deriving (Eq, Ord, Read, Show) + +_SimpleConditionalExpression = Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression" + +_SimpleConditionalExpression_condition = Model.Name "condition" + +_SimpleConditionalExpression_true = Model.Name "true" + +_SimpleConditionalExpression_false = Model.Name "false" + +-- | A simple identifier reference, with an optional list of explicit type arguments. +data SimpleName = + SimpleName { + simpleNameIdentifier :: Identifier, + simpleNameTypeArguments :: (Maybe TypeArgumentList)} + deriving (Eq, Ord, Read, Show) + +_SimpleName = Model.Name "hydra.ext.csharp.syntax.SimpleName" + +_SimpleName_identifier = Model.Name "identifier" + +_SimpleName_typeArguments = Model.Name "typeArguments" + +-- | A numeric type or the bool type. +data SimpleType = + SimpleTypeNumeric NumericType | + SimpleTypeBool + deriving (Eq, Ord, Read, Show) + +_SimpleType = Model.Name "hydra.ext.csharp.syntax.SimpleType" + +_SimpleType_numeric = Model.Name "numeric" + +_SimpleType_bool = Model.Name "bool" + +-- | A catch clause naming an exception type and/or filter, with a handler block. +data SpecificCatchClause = + SpecificCatchClause { + specificCatchClauseSpecifier :: (Maybe ExceptionSpecifier), + specificCatchClauseFilter :: (Maybe BooleanExpression), + specificCatchClauseBody :: Block} + deriving (Eq, Ord, Read, Show) + +_SpecificCatchClause = Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause" + +_SpecificCatchClause_specifier = Model.Name "specifier" + +_SpecificCatchClause_filter = Model.Name "filter" + +_SpecificCatchClause_body = Model.Name "body" + +-- | A 'stackalloc' expression that allocates a block of memory on the stack. +data StackallocExpression = + StackallocExpression { + stackallocExpressionType :: (Maybe UnmanagedType), + stackallocExpressionExpression :: (Maybe ConstantExpression), + stackallocExpressionInitializer :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_StackallocExpression = Model.Name "hydra.ext.csharp.syntax.StackallocExpression" + +_StackallocExpression_type = Model.Name "type" + +_StackallocExpression_expression = Model.Name "expression" + +_StackallocExpression_initializer = Model.Name "initializer" + +-- | A field-like event declaration, with its type and one or more declarators. +data StandardEventDeclaration = + StandardEventDeclaration { + standardEventDeclarationAttributes :: (Maybe Attributes), + standardEventDeclarationModifiers :: [EventModifier], + standardEventDeclarationType :: Type, + standardEventDeclarationDeclarators :: VariableDeclarators} + deriving (Eq, Ord, Read, Show) + +_StandardEventDeclaration = Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration" + +_StandardEventDeclaration_attributes = Model.Name "attributes" + +_StandardEventDeclaration_modifiers = Model.Name "modifiers" + +_StandardEventDeclaration_type = Model.Name "type" + +_StandardEventDeclaration_declarators = Model.Name "declarators" + +-- | A standard (non-ref-returning) indexer declaration. +data StandardIndexerDeclaration = + StandardIndexerDeclaration { + standardIndexerDeclarationAttributes :: (Maybe Attributes), + standardIndexerDeclarationModifiers :: [IndexerModifier], + standardIndexerDeclarationDeclarator :: IndexerDeclarator, + standardIndexerDeclarationBody :: IndexerBody} + deriving (Eq, Ord, Read, Show) + +_StandardIndexerDeclaration = Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration" + +_StandardIndexerDeclaration_attributes = Model.Name "attributes" + +_StandardIndexerDeclaration_modifiers = Model.Name "modifiers" + +_StandardIndexerDeclaration_declarator = Model.Name "declarator" + +_StandardIndexerDeclaration_body = Model.Name "body" + +-- | A standard (non-ref-returning) local function declaration. +data StandardLocalFunctionDeclaration = + StandardLocalFunctionDeclaration { + standardLocalFunctionDeclarationModifiers :: [LocalFunctionModifier], + standardLocalFunctionDeclarationReturnType :: ReturnType, + standardLocalFunctionDeclarationHeader :: LocalFunctionHeader, + standardLocalFunctionDeclarationBody :: LocalFunctionBody} + deriving (Eq, Ord, Read, Show) + +_StandardLocalFunctionDeclaration = Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration" + +_StandardLocalFunctionDeclaration_modifiers = Model.Name "modifiers" + +_StandardLocalFunctionDeclaration_returnType = Model.Name "returnType" + +_StandardLocalFunctionDeclaration_header = Model.Name "header" + +_StandardLocalFunctionDeclaration_body = Model.Name "body" + +-- | A standard (non-ref-returning) method declaration. +data StandardMethodDeclaration = + StandardMethodDeclaration { + standardMethodDeclarationAttributes :: (Maybe Attributes), + standardMethodDeclarationModifiers :: [MethodModifier], + standardMethodDeclarationReturnType :: ReturnType, + standardMethodDeclarationHeader :: MethodHeader, + standardMethodDeclarationBody :: MethodBody} + deriving (Eq, Ord, Read, Show) + +_StandardMethodDeclaration = Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration" + +_StandardMethodDeclaration_attributes = Model.Name "attributes" + +_StandardMethodDeclaration_modifiers = Model.Name "modifiers" + +_StandardMethodDeclaration_returnType = Model.Name "returnType" + +_StandardMethodDeclaration_header = Model.Name "header" + +_StandardMethodDeclaration_body = Model.Name "body" + +-- | A standard (non-ref-returning) property declaration. +data StandardPropertyDeclaration = + StandardPropertyDeclaration { + standardPropertyDeclarationAttributes :: (Maybe Attributes), + standardPropertyDeclarationModifiers :: [PropertyModifier], + standardPropertyDeclarationType :: Type, + standardPropertyDeclarationName :: MemberName, + standardPropertyDeclarationBody :: PropertyBody} + deriving (Eq, Ord, Read, Show) + +_StandardPropertyDeclaration = Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration" + +_StandardPropertyDeclaration_attributes = Model.Name "attributes" + +_StandardPropertyDeclaration_modifiers = Model.Name "modifiers" + +_StandardPropertyDeclaration_type = Model.Name "type" + +_StandardPropertyDeclaration_name = Model.Name "name" + +_StandardPropertyDeclaration_body = Model.Name "body" + +-- | A labeled statement, a declaration statement, or an embedded statement. +data Statement = + StatementLabeled LabeledStatement | + StatementDeclaration DeclarationStatement | + StatementEmbedded EmbeddedStatement + deriving (Eq, Ord, Read, Show) + +_Statement = Model.Name "hydra.ext.csharp.syntax.Statement" + +_Statement_labeled = Model.Name "labeled" + +_Statement_declaration = Model.Name "declaration" + +_Statement_embedded = Model.Name "embedded" + +-- | An expression usable as a statement on its own, such as an invocation or assignment. +data StatementExpression = + StatementExpressionNullConditionalInvocation NullConditionalInvocationExpression | + StatementExpressionInvocation InvocationExpression | + StatementExpressionObjectCreation ObjectCreationExpression | + StatementExpressionAssignment Assignment | + StatementExpressionPostIncrement PrimaryExpression | + StatementExpressionPostDecrement PrimaryExpression | + StatementExpressionPreIncrement UnaryExpression | + StatementExpressionPreDecrement UnaryExpression | + StatementExpressionAwait UnaryExpression + deriving (Eq, Ord, Read, Show) + +_StatementExpression = Model.Name "hydra.ext.csharp.syntax.StatementExpression" + +_StatementExpression_nullConditionalInvocation = Model.Name "nullConditionalInvocation" + +_StatementExpression_invocation = Model.Name "invocation" + +_StatementExpression_objectCreation = Model.Name "objectCreation" + +_StatementExpression_assignment = Model.Name "assignment" + +_StatementExpression_postIncrement = Model.Name "postIncrement" + +_StatementExpression_postDecrement = Model.Name "postDecrement" + +_StatementExpression_preIncrement = Model.Name "preIncrement" + +_StatementExpression_preDecrement = Model.Name "preDecrement" + +_StatementExpression_await = Model.Name "await" + +-- | A non-empty, comma-separated list of statement expressions, as used in a for statement. +newtype StatementExpressionList = + StatementExpressionList { + unStatementExpressionList :: [StatementExpression]} + deriving (Eq, Ord, Read, Show) + +_StatementExpressionList = Model.Name "hydra.ext.csharp.syntax.StatementExpressionList" + +-- | The body of a static constructor: a block, expression body, or empty (extern) body. +data StaticConstructorBody = + StaticConstructorBodyBlock Block | + StaticConstructorBodyExpression Expression | + StaticConstructorBodyEmpty + deriving (Eq, Ord, Read, Show) + +_StaticConstructorBody = Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody" + +_StaticConstructorBody_block = Model.Name "block" + +_StaticConstructorBody_expression = Model.Name "expression" + +_StaticConstructorBody_empty = Model.Name "empty" + +-- | A static constructor declaration for a type. +data StaticConstructorDeclaration = + StaticConstructorDeclaration { + staticConstructorDeclarationAttributes :: (Maybe Attributes), + staticConstructorDeclarationModifiers :: StaticConstructorModifiers, + staticConstructorDeclarationName :: Identifier, + staticConstructorDeclarationBody :: StaticConstructorBody} + deriving (Eq, Ord, Read, Show) + +_StaticConstructorDeclaration = Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration" + +_StaticConstructorDeclaration_attributes = Model.Name "attributes" + +_StaticConstructorDeclaration_modifiers = Model.Name "modifiers" + +_StaticConstructorDeclaration_name = Model.Name "name" + +_StaticConstructorDeclaration_body = Model.Name "body" + +-- | The extern and unsafe flags of a static constructor declaration. +data StaticConstructorModifiers = + StaticConstructorModifiers { + staticConstructorModifiersExtern :: Bool, + staticConstructorModifiersUnsafe :: Bool} + deriving (Eq, Ord, Read, Show) + +_StaticConstructorModifiers = Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers" + +_StaticConstructorModifiers_extern = Model.Name "extern" + +_StaticConstructorModifiers_unsafe = Model.Name "unsafe" + +-- | A struct type declaration, with its modifiers, type parameters, interfaces, and body. +data StructDeclaration = + StructDeclaration { + structDeclarationAttributes :: (Maybe Attributes), + structDeclarationModifiers :: [StructModifier], + structDeclarationRef :: Bool, + structDeclarationPartial :: Bool, + structDeclarationName :: Identifier, + structDeclarationParameters :: (Maybe TypeParameterList), + structDeclarationInterfaces :: [InterfaceType], + structDeclarationConstraints :: [TypeParameterConstraintsClause], + structDeclarationBody :: [StructMemberDeclaration]} + deriving (Eq, Ord, Read, Show) + +_StructDeclaration = Model.Name "hydra.ext.csharp.syntax.StructDeclaration" + +_StructDeclaration_attributes = Model.Name "attributes" + +_StructDeclaration_modifiers = Model.Name "modifiers" + +_StructDeclaration_ref = Model.Name "ref" + +_StructDeclaration_partial = Model.Name "partial" + +_StructDeclaration_name = Model.Name "name" + +_StructDeclaration_parameters = Model.Name "parameters" + +_StructDeclaration_interfaces = Model.Name "interfaces" + +_StructDeclaration_constraints = Model.Name "constraints" + +_StructDeclaration_body = Model.Name "body" + +-- | Any member that can appear in a struct body, including fixed-size buffer declarations. +data StructMemberDeclaration = + StructMemberDeclarationConstant ConstantDeclaration | + StructMemberDeclarationField FieldDeclaration | + StructMemberDeclarationMethod MethodDeclaration | + StructMemberDeclarationProperty PropertyDeclaration | + StructMemberDeclarationEvent EventDeclaration | + StructMemberDeclarationIndexer IndexerDeclaration | + StructMemberDeclarationOperator OperatorDeclaration | + StructMemberDeclarationConstructor ConstructorDeclaration | + StructMemberDeclarationStaticConstructor StaticConstructorDeclaration | + StructMemberDeclarationType TypeDeclaration | + StructMemberDeclarationFixedSizeBuffer FixedSizeBufferDeclaration + deriving (Eq, Ord, Read, Show) + +_StructMemberDeclaration = Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration" + +_StructMemberDeclaration_constant = Model.Name "constant" + +_StructMemberDeclaration_field = Model.Name "field" + +_StructMemberDeclaration_method = Model.Name "method" + +_StructMemberDeclaration_property = Model.Name "property" + +_StructMemberDeclaration_event = Model.Name "event" + +_StructMemberDeclaration_indexer = Model.Name "indexer" + +_StructMemberDeclaration_operator = Model.Name "operator" + +_StructMemberDeclaration_constructor = Model.Name "constructor" + +_StructMemberDeclaration_staticConstructor = Model.Name "staticConstructor" + +_StructMemberDeclaration_type = Model.Name "type" + +_StructMemberDeclaration_fixedSizeBuffer = Model.Name "fixedSizeBuffer" + +-- | A modifier keyword on a struct declaration, such as readonly or unsafe. +data StructModifier = + StructModifierNew | + StructModifierPublic | + StructModifierProtected | + StructModifierInternal | + StructModifierPrivate | + StructModifierReadonly | + StructModifierUnsafe + deriving (Eq, Ord, Read, Show) + +_StructModifier = Model.Name "hydra.ext.csharp.syntax.StructModifier" + +_StructModifier_new = Model.Name "new" + +_StructModifier_public = Model.Name "public" + +_StructModifier_protected = Model.Name "protected" + +_StructModifier_internal = Model.Name "internal" + +_StructModifier_private = Model.Name "private" + +_StructModifier_readonly = Model.Name "readonly" + +_StructModifier_unsafe = Model.Name "unsafe" + +-- | A struct type or an enum type, as used in the definition of value types. +data StructOrEnumType = + StructOrEnumTypeStruct StructType | + StructOrEnumTypeEnum EnumType + deriving (Eq, Ord, Read, Show) + +_StructOrEnumType = Model.Name "hydra.ext.csharp.syntax.StructOrEnumType" + +_StructOrEnumType_struct = Model.Name "struct" + +_StructOrEnumType_enum = Model.Name "enum" + +-- | A reference to a struct type: a named type, a simple type, or a tuple type. +data StructType = + StructTypeTypeName TypeName | + StructTypeSimple SimpleType | + StructTypeTuple TupleType + deriving (Eq, Ord, Read, Show) + +_StructType = Model.Name "hydra.ext.csharp.syntax.StructType" + +_StructType_typeName = Model.Name "typeName" + +_StructType_simple = Model.Name "simple" + +_StructType_tuple = Model.Name "tuple" + +-- | A pattern and optional guard expression used in a pattern-matching switch section. +data SwitchBranch = + SwitchBranch { + switchBranchPattern :: Pattern, + switchBranchGuard :: (Maybe Expression)} + deriving (Eq, Ord, Read, Show) + +_SwitchBranch = Model.Name "hydra.ext.csharp.syntax.SwitchBranch" + +_SwitchBranch_pattern = Model.Name "pattern" + +_SwitchBranch_guard = Model.Name "guard" + +-- | A single label of a switch section: a pattern branch, or the default label. +data SwitchLabel = + SwitchLabelBranch SwitchBranch | + SwitchLabelDefault + deriving (Eq, Ord, Read, Show) + +_SwitchLabel = Model.Name "hydra.ext.csharp.syntax.SwitchLabel" + +_SwitchLabel_branch = Model.Name "branch" + +_SwitchLabel_default = Model.Name "default" + +-- | A group of switch labels sharing a common statement list within a switch statement. +data SwitchSection = + SwitchSection { + switchSectionLabels :: [SwitchLabel], + switchSectionStatements :: [Statement]} + deriving (Eq, Ord, Read, Show) + +_SwitchSection = Model.Name "hydra.ext.csharp.syntax.SwitchSection" + +_SwitchSection_labels = Model.Name "labels" + +_SwitchSection_statements = Model.Name "statements" + +-- | A switch statement, dispatching on an expression across its switch sections. +data SwitchStatement = + SwitchStatement { + switchStatementExpression :: Expression, + switchStatementBranches :: [SwitchSection]} + deriving (Eq, Ord, Read, Show) + +_SwitchStatement = Model.Name "hydra.ext.csharp.syntax.SwitchStatement" + +_SwitchStatement_expression = Model.Name "expression" + +_SwitchStatement_branches = Model.Name "branches" + +-- | A try statement with its protected block, catch clauses, and optional finally block. +data TryStatement = + TryStatement { + tryStatementBody :: Block, + tryStatementCatches :: CatchClauses, + tryStatementFinally :: (Maybe Block)} + deriving (Eq, Ord, Read, Show) + +_TryStatement = Model.Name "hydra.ext.csharp.syntax.TryStatement" + +_TryStatement_body = Model.Name "body" + +_TryStatement_catches = Model.Name "catches" + +_TryStatement_finally = Model.Name "finally" + +-- | A single element of a tuple expression, with an optional name. +data TupleElement = + TupleElement { + tupleElementName :: (Maybe Identifier), + tupleElementExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_TupleElement = Model.Name "hydra.ext.csharp.syntax.TupleElement" + +_TupleElement_name = Model.Name "name" + +_TupleElement_expression = Model.Name "expression" + +-- | A tuple literal expression, either a list of named elements or a deconstruction tuple. +data TupleExpression = + TupleExpressionElements [TupleElement] | + TupleExpressionDeconstruction DeconstructionTuple + deriving (Eq, Ord, Read, Show) + +_TupleExpression = Model.Name "hydra.ext.csharp.syntax.TupleExpression" + +_TupleExpression_elements = Model.Name "elements" + +_TupleExpression_deconstruction = Model.Name "deconstruction" + +-- | A tuple type formed from a non-empty list of named or unnamed element types. +newtype TupleType = + TupleType { + unTupleType :: [TupleTypeElement]} + deriving (Eq, Ord, Read, Show) + +_TupleType = Model.Name "hydra.ext.csharp.syntax.TupleType" + +-- | A single element type of a tuple type, with an optional element name. +data TupleTypeElement = + TupleTypeElement { + tupleTypeElementType :: Type, + tupleTypeElementIdentifier :: (Maybe Identifier)} + deriving (Eq, Ord, Read, Show) + +_TupleTypeElement = Model.Name "hydra.ext.csharp.syntax.TupleTypeElement" + +_TupleTypeElement_type = Model.Name "type" + +_TupleTypeElement_identifier = Model.Name "identifier" + +-- | A C# type: a reference type, value type, type parameter, or pointer type. +data Type = + TypeReference ReferenceType | + TypeValue ValueType | + TypeParam TypeParameter | + TypePointer PointerType + deriving (Eq, Ord, Read, Show) + +_Type = Model.Name "hydra.ext.csharp.syntax.Type" + +_Type_reference = Model.Name "reference" + +_Type_value = Model.Name "value" + +_Type_param = Model.Name "param" + +_Type_pointer = Model.Name "pointer" + +-- | A list of type arguments supplied to a generic type or method. +newtype TypeArgumentList = + TypeArgumentList { + unTypeArgumentList :: [Type]} + deriving (Eq, Ord, Read, Show) + +_TypeArgumentList = Model.Name "hydra.ext.csharp.syntax.TypeArgumentList" + +-- | A top-level or nested type declaration: class, struct, interface, enum, or delegate. +data TypeDeclaration = + TypeDeclarationClass ClassDeclaration | + TypeDeclarationStruct StructDeclaration | + TypeDeclarationInterface InterfaceDeclaration | + TypeDeclarationEnum EnumDeclaration | + TypeDeclarationDelegate DelegateDeclaration + deriving (Eq, Ord, Read, Show) + +_TypeDeclaration = Model.Name "hydra.ext.csharp.syntax.TypeDeclaration" + +_TypeDeclaration_class = Model.Name "class" + +_TypeDeclaration_struct = Model.Name "struct" + +_TypeDeclaration_interface = Model.Name "interface" + +_TypeDeclaration_enum = Model.Name "enum" + +_TypeDeclaration_delegate = Model.Name "delegate" + +-- | A name that is known to refer to a type, expressed as a namespace-or-type name. +newtype TypeName = + TypeName { + unTypeName :: NamespaceOrTypeName} + deriving (Eq, Ord, Read, Show) + +_TypeName = Model.Name "hydra.ext.csharp.syntax.TypeName" + +-- | A single generic type parameter, identified by its name. +newtype TypeParameter = + TypeParameter { + unTypeParameter :: Identifier} + deriving (Eq, Ord, Read, Show) + +_TypeParameter = Model.Name "hydra.ext.csharp.syntax.TypeParameter" + +-- | The primary, secondary, and constructor constraints on a single type parameter. +data TypeParameterConstraints = + TypeParameterConstraints { + typeParameterConstraintsPrimary :: (Maybe PrimaryConstraint), + typeParameterConstraintsSecondary :: (Maybe SecondaryConstraints), + typeParameterConstraintsConstructor :: Bool} + deriving (Eq, Ord, Read, Show) + +_TypeParameterConstraints = Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints" + +_TypeParameterConstraints_primary = Model.Name "primary" + +_TypeParameterConstraints_secondary = Model.Name "secondary" + +_TypeParameterConstraints_constructor = Model.Name "constructor" + +-- | A 'where T : ...' clause constraining one type parameter of a generic declaration. +data TypeParameterConstraintsClause = + TypeParameterConstraintsClause { + typeParameterConstraintsClauseParameter :: TypeParameter, + typeParameterConstraintsClauseConstraints :: [TypeParameterConstraints]} + deriving (Eq, Ord, Read, Show) + +_TypeParameterConstraintsClause = Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause" + +_TypeParameterConstraintsClause_parameter = Model.Name "parameter" + +_TypeParameterConstraintsClause_constraints = Model.Name "constraints" + +-- | A non-empty, comma-separated list of type parameters in a generic declaration. +newtype TypeParameterList = + TypeParameterList { + unTypeParameterList :: [TypeParameterPart]} + deriving (Eq, Ord, Read, Show) + +_TypeParameterList = Model.Name "hydra.ext.csharp.syntax.TypeParameterList" + +-- | A single type parameter within a type parameter list, with its optional attributes. +data TypeParameterPart = + TypeParameterPart { + typeParameterPartAttributes :: (Maybe Attributes), + typeParameterPartName :: TypeParameter} + deriving (Eq, Ord, Read, Show) + +_TypeParameterPart = Model.Name "hydra.ext.csharp.syntax.TypeParameterPart" + +_TypeParameterPart_attributes = Model.Name "attributes" + +_TypeParameterPart_name = Model.Name "name" + +-- | A 'typeof' expression yielding the System.Type of a type, unbound generic type, or void. +data TypeofExpression = + TypeofExpressionType Type | + TypeofExpressionUnboundTypeName UnboundTypeName | + TypeofExpressionVoid + deriving (Eq, Ord, Read, Show) + +_TypeofExpression = Model.Name "hydra.ext.csharp.syntax.TypeofExpression" + +_TypeofExpression_type = Model.Name "type" + +_TypeofExpression_unboundTypeName = Model.Name "unboundTypeName" + +_TypeofExpression_void = Model.Name "void" + +-- | A unary expression: a primary expression, or a prefixed unary/cast/await operation. +data UnaryExpression = + UnaryExpressionPrimary PrimaryExpression | + UnaryExpressionPlus UnaryExpression | + UnaryExpressionMinus UnaryExpression | + UnaryExpressionNot UnaryExpression | + UnaryExpressionBitwiseComplement UnaryExpression | + UnaryExpressionPreIncrement UnaryExpression | + UnaryExpressionPreDecrement UnaryExpression | + UnaryExpressionCast CastExpression | + UnaryExpressionAwait UnaryExpression | + UnaryExpressionPointerIndirection UnaryExpression | + UnaryExpressionAddressOf UnaryExpression + deriving (Eq, Ord, Read, Show) + +_UnaryExpression = Model.Name "hydra.ext.csharp.syntax.UnaryExpression" + +_UnaryExpression_primary = Model.Name "primary" + +_UnaryExpression_plus = Model.Name "plus" + +_UnaryExpression_minus = Model.Name "minus" + +_UnaryExpression_not = Model.Name "not" + +_UnaryExpression_bitwiseComplement = Model.Name "bitwiseComplement" + +_UnaryExpression_preIncrement = Model.Name "preIncrement" + +_UnaryExpression_preDecrement = Model.Name "preDecrement" + +_UnaryExpression_cast = Model.Name "cast" + +_UnaryExpression_await = Model.Name "await" + +_UnaryExpression_pointerIndirection = Model.Name "pointerIndirection" + +_UnaryExpression_addressOf = Model.Name "addressOf" + +-- | The declarator for a user-defined unary operator overload, naming its single parameter. +data UnaryOperatorDeclarator = + UnaryOperatorDeclarator { + unaryOperatorDeclaratorType :: Type, + unaryOperatorDeclaratorOperator :: OverloadableUnaryOperator, + unaryOperatorDeclaratorParameter :: FixedParameter} + deriving (Eq, Ord, Read, Show) + +_UnaryOperatorDeclarator = Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator" + +_UnaryOperatorDeclarator_type = Model.Name "type" + +_UnaryOperatorDeclarator_operator = Model.Name "operator" + +_UnaryOperatorDeclarator_parameter = Model.Name "parameter" + +-- | An unbound generic type name, as used in a typeof expression (e.g. Dictionary<,>). +newtype UnboundTypeName = + UnboundTypeName { + unUnboundTypeName :: [UnboundTypeNamePart]} + deriving (Eq, Ord, Read, Show) + +_UnboundTypeName = Model.Name "hydra.ext.csharp.syntax.UnboundTypeName" + +-- | A single segment of an unbound type name, with its aliasing flag and generic dimension. +data UnboundTypeNamePart = + UnboundTypeNamePart { + unboundTypeNamePartIdentifier :: Identifier, + unboundTypeNamePartAliased :: Bool, + unboundTypeNamePartDimension :: (Maybe Int)} + deriving (Eq, Ord, Read, Show) + +_UnboundTypeNamePart = Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart" + +_UnboundTypeNamePart_identifier = Model.Name "identifier" + +_UnboundTypeNamePart_aliased = Model.Name "aliased" + +_UnboundTypeNamePart_dimension = Model.Name "dimension" + +-- | A type usable with the unsafe 'sizeof' operator: a value type or pointer type. +data UnmanagedType = + UnmanagedTypeValue ValueType | + UnmanagedTypePointer PointerType + deriving (Eq, Ord, Read, Show) + +_UnmanagedType = Model.Name "hydra.ext.csharp.syntax.UnmanagedType" + +_UnmanagedType_value = Model.Name "value" + +_UnmanagedType_pointer = Model.Name "pointer" + +-- | A 'using alias = namespace-or-type;' directive introducing a using alias. +data UsingAliasDirective = + UsingAliasDirective { + usingAliasDirectiveAlias :: Identifier, + usingAliasDirectiveName :: NamespaceOrTypeName} + deriving (Eq, Ord, Read, Show) + +_UsingAliasDirective = Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective" + +_UsingAliasDirective_alias = Model.Name "alias" + +_UsingAliasDirective_name = Model.Name "name" + +-- | A using directive: an alias directive, a namespace import, or a using-static directive. +data UsingDirective = + UsingDirectiveAlias UsingAliasDirective | + UsingDirectiveNamespace NamespaceName | + UsingDirectiveStatic TypeName + deriving (Eq, Ord, Read, Show) + +_UsingDirective = Model.Name "hydra.ext.csharp.syntax.UsingDirective" + +_UsingDirective_alias = Model.Name "alias" + +_UsingDirective_namespace = Model.Name "namespace" + +_UsingDirective_static = Model.Name "static" + +-- | A 'using' statement that deterministically disposes an acquired resource after its body. +data UsingStatement = + UsingStatement { + usingStatementAcquisition :: ResourceAcquisition, + usingStatementBody :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_UsingStatement = Model.Name "hydra.ext.csharp.syntax.UsingStatement" + +_UsingStatement_acquisition = Model.Name "acquisition" + +_UsingStatement_body = Model.Name "body" + +-- | A struct or enum type, in its non-nullable or nullable ('?') form. +data ValueType = + ValueTypeNonNullable StructOrEnumType | + ValueTypeNullable StructOrEnumType + deriving (Eq, Ord, Read, Show) + +_ValueType = Model.Name "hydra.ext.csharp.syntax.ValueType" + +_ValueType_nonNullable = Model.Name "nonNullable" + +_ValueType_nullable = Model.Name "nullable" + +-- | An identifier and optional initializer within a field or local variable declaration. +data VariableDeclarator = + VariableDeclarator { + variableDeclaratorIdentifier :: Identifier, + variableDeclaratorInitializer :: (Maybe VariableInitializer)} + deriving (Eq, Ord, Read, Show) + +_VariableDeclarator = Model.Name "hydra.ext.csharp.syntax.VariableDeclarator" + +_VariableDeclarator_identifier = Model.Name "identifier" + +_VariableDeclarator_initializer = Model.Name "initializer" + +-- | A non-empty, comma-separated list of variable declarators, as used in an event declaration. +newtype VariableDeclarators = + VariableDeclarators { + unVariableDeclarators :: [VariableDeclarator]} + deriving (Eq, Ord, Read, Show) + +_VariableDeclarators = Model.Name "hydra.ext.csharp.syntax.VariableDeclarators" + +-- | The initializer of a variable: an expression or a nested array initializer. +data VariableInitializer = + VariableInitializerExpression Expression | + VariableInitializerArray ArrayInitializer + deriving (Eq, Ord, Read, Show) + +_VariableInitializer = Model.Name "hydra.ext.csharp.syntax.VariableInitializer" + +_VariableInitializer_expression = Model.Name "expression" + +_VariableInitializer_array = Model.Name "array" + +-- | A reference to a variable, expressed as an expression. +newtype VariableReference = + VariableReference { + unVariableReference :: Expression} + deriving (Eq, Ord, Read, Show) + +_VariableReference = Model.Name "hydra.ext.csharp.syntax.VariableReference" + +-- | The in (contravariant) or out (covariant) variance annotation on a generic type parameter. +data VarianceAnnotation = + VarianceAnnotationIn | + VarianceAnnotationOut + deriving (Eq, Ord, Read, Show) + +_VarianceAnnotation = Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation" + +_VarianceAnnotation_in = Model.Name "in" + +_VarianceAnnotation_out = Model.Name "out" + +-- | A single type parameter of an interface or delegate, with optional variance annotation. +data VariantTypeParameter = + VariantTypeParameter { + variantTypeParameterAttributes :: (Maybe Attributes), + variantTypeParameterVariance :: (Maybe VarianceAnnotation), + variantTypeParameterParameter :: TypeParameter} + deriving (Eq, Ord, Read, Show) + +_VariantTypeParameter = Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter" + +_VariantTypeParameter_attributes = Model.Name "attributes" + +_VariantTypeParameter_variance = Model.Name "variance" + +_VariantTypeParameter_parameter = Model.Name "parameter" + +-- | The list of variant type parameters declared by a generic interface or delegate. +newtype VariantTypeParameters = + VariantTypeParameters { + unVariantTypeParameters :: [VariantTypeParameter]} + deriving (Eq, Ord, Read, Show) + +_VariantTypeParameters = Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters" + +-- | A single '{expression[,width][:format]}' hole within a verbatim interpolated string. +data VerbatimInterpolation = + VerbatimInterpolation { + verbatimInterpolationExpression :: Expression, + verbatimInterpolationWidth :: (Maybe ConstantExpression), + verbatimInterpolationFormat :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_VerbatimInterpolation = Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation" + +_VerbatimInterpolation_expression = Model.Name "expression" + +_VerbatimInterpolation_width = Model.Name "width" + +_VerbatimInterpolation_format = Model.Name "format" + +-- | A while iteration statement that tests its condition before each execution of the body. +data WhileStatement = + WhileStatement { + whileStatementCondition :: BooleanExpression, + whileStatementBody :: EmbeddedStatement} + deriving (Eq, Ord, Read, Show) + +_WhileStatement = Model.Name "hydra.ext.csharp.syntax.WhileStatement" + +_WhileStatement_condition = Model.Name "condition" + +_WhileStatement_body = Model.Name "body" + +-- | A 'yield return' or 'yield break' statement used within an iterator. +data YieldStatement = + YieldStatementReturn Expression | + YieldStatementBreak + deriving (Eq, Ord, Read, Show) + +_YieldStatement = Model.Name "hydra.ext.csharp.syntax.YieldStatement" + +_YieldStatement_return = Model.Name "return" + +_YieldStatement_break = Model.Name "break" diff --git a/src/main/haskell/Hydra/Ext/Datalog/Syntax.hs b/src/main/haskell/Hydra/Ext/Datalog/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Datalog/Syntax.hs @@ -0,0 +1,180 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A basic Datalog model + +module Hydra.Ext.Datalog.Syntax where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A relation applied to a list of terms +data Atom = + Atom { + atomRelation :: Relation, + atomTermList :: TermList} + deriving (Eq, Ord, Read, Show) + +_Atom = Model.Name "hydra.ext.datalog.syntax.Atom" + +_Atom_Relation = Model.Name "Relation" + +_Atom_TermList = Model.Name "TermList" + +-- | A nonempty, comma-separated list of atoms +data AtomList = + AtomListSingle Atom | + AtomListMany AtomListMultiple + deriving (Eq, Ord, Read, Show) + +_AtomList = Model.Name "hydra.ext.datalog.syntax.AtomList" + +_AtomList_single = Model.Name "single" + +_AtomList_many = Model.Name "many" + +-- | An atom followed by the remainder of a comma-separated atom list +data AtomListMultiple = + AtomListMultiple { + atomListMultipleAtom :: Atom, + atomListMultipleAtomList :: AtomList} + deriving (Eq, Ord, Read, Show) + +_AtomListMultiple = Model.Name "hydra.ext.datalog.syntax.AtomListMultiple" + +_AtomListMultiple_Atom = Model.Name "Atom" + +_AtomListMultiple_AtomList = Model.Name "AtomList" + +-- | A constant term, e.g. an atomic value such as a symbol or number +newtype Constant = + Constant { + unConstant :: String} + deriving (Eq, Ord, Read, Show) + +_Constant = Model.Name "hydra.ext.datalog.syntax.Constant" + +-- | A nonempty, comma-separated list of constants +data ConstantList = + ConstantListSingle Constant | + ConstantListMany ConstantListMultiple + deriving (Eq, Ord, Read, Show) + +_ConstantList = Model.Name "hydra.ext.datalog.syntax.ConstantList" + +_ConstantList_single = Model.Name "single" + +_ConstantList_many = Model.Name "many" + +-- | A constant followed by the remainder of a comma-separated constant list +data ConstantListMultiple = + ConstantListMultiple { + constantListMultipleConstant :: Constant, + constantListMultipleConstantList :: ConstantList} + deriving (Eq, Ord, Read, Show) + +_ConstantListMultiple = Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple" + +_ConstantListMultiple_Constant = Model.Name "Constant" + +_ConstantListMultiple_ConstantList = Model.Name "ConstantList" + +-- | An unconditional assertion of a relation applied to a list of constants +data Fact = + Fact { + factRelation :: Relation, + factConstantList :: ConstantList} + deriving (Eq, Ord, Read, Show) + +_Fact = Model.Name "hydra.ext.datalog.syntax.Fact" + +_Fact_Relation = Model.Name "Relation" + +_Fact_ConstantList = Model.Name "ConstantList" + +-- | A Datalog program: a list of facts and rules +newtype Program = + Program { + unProgram :: [ProgramElmt]} + deriving (Eq, Ord, Read, Show) + +_Program = Model.Name "hydra.ext.datalog.syntax.Program" + +-- | A single element of a Datalog program: either a fact or a rule +data ProgramElmt = + ProgramElmtFact Fact | + ProgramElmtRule Rule + deriving (Eq, Ord, Read, Show) + +_ProgramElmt = Model.Name "hydra.ext.datalog.syntax.ProgramElmt" + +_ProgramElmt_Fact = Model.Name "Fact" + +_ProgramElmt_Rule = Model.Name "Rule" + +-- | The name of a predicate (relation) used in facts, rules, and queries +newtype Relation = + Relation { + unRelation :: String} + deriving (Eq, Ord, Read, Show) + +_Relation = Model.Name "hydra.ext.datalog.syntax.Relation" + +-- | A conditional assertion: a head atom implied by a conjunction of body atoms +data Rule = + Rule { + ruleAtom :: Atom, + ruleAtomList :: AtomList} + deriving (Eq, Ord, Read, Show) + +_Rule = Model.Name "hydra.ext.datalog.syntax.Rule" + +_Rule_Atom = Model.Name "Atom" + +_Rule_AtomList = Model.Name "AtomList" + +-- | An argument to an atom: either a constant or a variable +data Term = + TermConstant Constant | + TermVariable Variable + deriving (Eq, Ord, Read, Show) + +_Term = Model.Name "hydra.ext.datalog.syntax.Term" + +_Term_Constant = Model.Name "Constant" + +_Term_Variable = Model.Name "Variable" + +-- | A nonempty, comma-separated list of terms +data TermList = + TermListSingle Term | + TermListMany TermListMultiple + deriving (Eq, Ord, Read, Show) + +_TermList = Model.Name "hydra.ext.datalog.syntax.TermList" + +_TermList_single = Model.Name "single" + +_TermList_many = Model.Name "many" + +-- | A term followed by the remainder of a comma-separated term list +data TermListMultiple = + TermListMultiple { + termListMultipleTerm :: Term, + termListMultipleTermList :: TermList} + deriving (Eq, Ord, Read, Show) + +_TermListMultiple = Model.Name "hydra.ext.datalog.syntax.TermListMultiple" + +_TermListMultiple_Term = Model.Name "Term" + +_TermListMultiple_TermList = Model.Name "TermList" + +-- | A logic variable, which may be bound to different constants across a query +newtype Variable = + Variable { + unVariable :: String} + deriving (Eq, Ord, Read, Show) + +_Variable = Model.Name "hydra.ext.datalog.syntax.Variable" diff --git a/src/main/haskell/Hydra/Ext/Delta/Parquet.hs b/src/main/haskell/Hydra/Ext/Delta/Parquet.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Delta/Parquet.hs @@ -0,0 +1,154 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A partial Delta Parquet model, based on DataType and its subclasses as specified in the 3.0.0 Java API: https://docs.delta.io/3.0.0/api/java/kernel/io/delta/kernel/types/DataType.html + +module Hydra.Ext.Delta.Parquet where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Represent array data type. +data ArrayType = + ArrayType { + arrayTypeElementType :: DataType, + arrayTypeContainsNull :: Bool} + deriving (Eq, Ord, Read, Show) + +_ArrayType = Model.Name "hydra.ext.delta.parquet.ArrayType" + +_ArrayType_elementType = Model.Name "elementType" + +_ArrayType_containsNull = Model.Name "containsNull" + +-- | Base class for all primitive types DataType. +data BasePrimitiveType = + -- | The data type representing byte[] values. + BasePrimitiveTypeBinary | + -- | Data type representing boolean type values. + BasePrimitiveTypeBoolean | + -- | The data type representing byte type values. + BasePrimitiveTypeByte | + -- | A date type, supporting "0001-01-01" through "9999-12-31". Internally, this is represented as the number of days from 1970-01-01. + BasePrimitiveTypeDate | + -- | The data type representing double type values. + BasePrimitiveTypeDouble | + -- | The data type representing float type values. + BasePrimitiveTypeFloat | + -- | The data type representing integer type values. + BasePrimitiveTypeInteger | + -- | The data type representing long type values. + BasePrimitiveTypeLong | + -- | The data type representing short type values. + BasePrimitiveTypeShort | + -- | The data type representing string type values. + BasePrimitiveTypeString | + -- | A timestamp type, supporting [0001-01-01T00:00:00.000000Z, 9999-12-31T23:59:59.999999Z] where the left/right-bound is a date and time of the proleptic Gregorian calendar in UTC+00:00. Internally, this is represented as the number of microseconds since the Unix epoch, 1970-01-01 00:00:00 UTC. + BasePrimitiveTypeTimestamp + deriving (Eq, Ord, Read, Show) + +_BasePrimitiveType = Model.Name "hydra.ext.delta.parquet.BasePrimitiveType" + +_BasePrimitiveType_binary = Model.Name "binary" + +_BasePrimitiveType_boolean = Model.Name "boolean" + +_BasePrimitiveType_byte = Model.Name "byte" + +_BasePrimitiveType_date = Model.Name "date" + +_BasePrimitiveType_double = Model.Name "double" + +_BasePrimitiveType_float = Model.Name "float" + +_BasePrimitiveType_integer = Model.Name "integer" + +_BasePrimitiveType_long = Model.Name "long" + +_BasePrimitiveType_short = Model.Name "short" + +_BasePrimitiveType_string = Model.Name "string" + +_BasePrimitiveType_timestamp = Model.Name "timestamp" + +-- | A Delta Parquet data type, either array, primitive, decimal, map, or struct. +data DataType = + -- | Represent array data type. + DataTypeArray ArrayType | + -- | Base class for all primitive types DataType. + DataTypeBase BasePrimitiveType | + -- | A decimal data type. + DataTypeDecimal DecimalType | + -- | Data type representing a map type. + DataTypeMap MapType | + -- | Struct type which contains one or more columns. + DataTypeStruct StructType + deriving (Eq, Ord, Read, Show) + +_DataType = Model.Name "hydra.ext.delta.parquet.DataType" + +_DataType_array = Model.Name "array" + +_DataType_base = Model.Name "base" + +_DataType_decimal = Model.Name "decimal" + +_DataType_map = Model.Name "map" + +_DataType_struct = Model.Name "struct" + +-- | A decimal data type with fixed precision (the maximum number of digits) and scale (the number of digits on right side of dot). The precision can be up to 38, scale can also be up to 38 (less or equal to precision). +data DecimalType = + DecimalType { + decimalTypePrecision :: Int, + decimalTypeScale :: Int} + deriving (Eq, Ord, Read, Show) + +_DecimalType = Model.Name "hydra.ext.delta.parquet.DecimalType" + +_DecimalType_precision = Model.Name "precision" + +_DecimalType_scale = Model.Name "scale" + +-- | Data type representing a map type. +data MapType = + MapType { + mapTypeKeyType :: DataType, + mapTypeValueType :: DataType, + mapTypeValueContainsNull :: Bool} + deriving (Eq, Ord, Read, Show) + +_MapType = Model.Name "hydra.ext.delta.parquet.MapType" + +_MapType_keyType = Model.Name "keyType" + +_MapType_valueType = Model.Name "valueType" + +_MapType_valueContainsNull = Model.Name "valueContainsNull" + +-- | Represents a subfield of StructType with additional properties and metadata. +data StructField = + StructField { + structFieldName :: String, + structFieldDataType :: DataType, + structFieldNullable :: Bool} + deriving (Eq, Ord, Read, Show) + +_StructField = Model.Name "hydra.ext.delta.parquet.StructField" + +_StructField_name = Model.Name "name" + +_StructField_dataType = Model.Name "dataType" + +_StructField_nullable = Model.Name "nullable" + +-- | Struct type which contains one or more columns. +data StructType = + StructType { + structTypeFields :: [StructField]} + deriving (Eq, Ord, Read, Show) + +_StructType = Model.Name "hydra.ext.delta.parquet.StructType" + +_StructType_fields = Model.Name "fields" diff --git a/src/main/haskell/Hydra/Ext/Dsl/Atlas.hs b/src/main/haskell/Hydra/Ext/Dsl/Atlas.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Atlas.hs @@ -0,0 +1,3926 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.atlas + +module Hydra.Ext.Dsl.Atlas where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Atlas as Atlas +import qualified Hydra.Rdf.Xml.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Int as I +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL constructor for hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDef :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefCardinality) -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefIndexType) -> Typed.TypedTerm [Atlas.AtlasConstraintDef] -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDef name typeName isOptional cardinality valuesMinCount valuesMaxCount isUnique isIndexable includeInNotification defaultValue description searchWeight indexType constraints options displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm typeName)}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Typed.unTypedTerm isOptional)}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Typed.unTypedTerm cardinality)}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Typed.unTypedTerm valuesMinCount)}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Typed.unTypedTerm valuesMaxCount)}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Typed.unTypedTerm isUnique)}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Typed.unTypedTerm isIndexable)}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Typed.unTypedTerm includeInNotification)}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Typed.unTypedTerm defaultValue)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Typed.unTypedTerm searchWeight)}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Typed.unTypedTerm indexType)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL name token for hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefAtlasAttributeDef :: Typed.TypedName Atlas.AtlasAttributeDef +atlasAttributeDefAtlasAttributeDef = Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasAttributeDef") + +-- | DSL accessor for the cardinality field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefCardinality :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefCardinality) +atlasAttributeDefCardinality x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalityAtlasAttributeDefCardinality :: Typed.TypedName Atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalityAtlasAttributeDefCardinality = + Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasAttributeDefCardinality") + +-- | DSL injection for the list variant of hydra.ext.atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalityList :: Typed.TypedTerm Atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalityList = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDefCardinality"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the set variant of hydra.ext.atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalitySet :: Typed.TypedTerm Atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalitySet = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDefCardinality"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the single variant of hydra.ext.atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalitySingle :: Typed.TypedTerm Atlas.AtlasAttributeDefCardinality +atlasAttributeDefCardinalitySingle = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDefCardinality"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the constraints field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefConstraints :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm [Atlas.AtlasConstraintDef] +atlasAttributeDefConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the defaultValue field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefDefaultValue :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) +atlasAttributeDefDefaultValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefDescription :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) +atlasAttributeDefDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefDisplayName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) +atlasAttributeDefDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the includeInNotification field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefIncludeInNotification :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool +atlasAttributeDefIncludeInNotification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the indexType field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefIndexType :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefIndexType) +atlasAttributeDefIndexType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeAtlasAttributeDefIndexType :: Typed.TypedName Atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeAtlasAttributeDefIndexType = + Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasAttributeDefIndexType") + +-- | DSL injection for the default variant of hydra.ext.atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeDefault :: Typed.TypedTerm Atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeDefault = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDefIndexType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeString :: Typed.TypedTerm Atlas.AtlasAttributeDefIndexType +atlasAttributeDefIndexTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDefIndexType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the isIndexable field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefIsIndexable :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool +atlasAttributeDefIsIndexable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isOptional field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefIsOptional :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool +atlasAttributeDefIsOptional x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isUnique field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefIsUnique :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool +atlasAttributeDefIsUnique x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) +atlasAttributeDefName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefOptions :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (M.Map String String) +atlasAttributeDefOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the searchWeight field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefSearchWeight :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int +atlasAttributeDefSearchWeight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeName field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefTypeName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) +atlasAttributeDefTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valuesMaxCount field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefValuesMaxCount :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int +atlasAttributeDefValuesMaxCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valuesMinCount field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefValuesMinCount :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int +atlasAttributeDefValuesMinCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the cardinality field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithCardinality :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefCardinality) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithCardinality original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the constraints field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithConstraints :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm [Atlas.AtlasConstraintDef] -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the defaultValue field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithDefaultValue :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithDefaultValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithDescription :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithDisplayName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the includeInNotification field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithIncludeInNotification :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithIncludeInNotification original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the indexType field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithIndexType :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe Atlas.AtlasAttributeDefIndexType) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithIndexType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isIndexable field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithIsIndexable :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithIsIndexable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isOptional field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithIsOptional :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithIsOptional original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isUnique field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithIsUnique :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithIsUnique original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithOptions :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the searchWeight field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithSearchWeight :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithSearchWeight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeName field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithTypeName :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithTypeName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the valuesMaxCount field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithValuesMaxCount :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithValuesMaxCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMinCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the valuesMinCount field of hydra.ext.atlas.AtlasAttributeDef +atlasAttributeDefWithValuesMinCount :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Int -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasAttributeDefWithValuesMinCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isOptional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isOptional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cardinality"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "cardinality")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valuesMinCount"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valuesMaxCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "valuesMaxCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isIndexable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "isIndexable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includeInNotification"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "includeInNotification")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "searchWeight"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "searchWeight")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "indexType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasAttributeDef"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDef :: Typed.TypedTerm (Maybe Atlas.TypeCategory) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Schema.DateTime) -> Typed.TypedTerm (Maybe Schema.DateTime) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDef category guid createdBy updatedBy createTime updateTime version name description typeVersion serviceType options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Typed.unTypedTerm category)}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Typed.unTypedTerm guid)}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Typed.unTypedTerm createdBy)}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Typed.unTypedTerm updatedBy)}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Typed.unTypedTerm createTime)}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Typed.unTypedTerm updateTime)}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Typed.unTypedTerm version)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Typed.unTypedTerm typeVersion)}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Typed.unTypedTerm serviceType)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL name token for hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefAtlasBaseTypeDef :: Typed.TypedName Atlas.AtlasBaseTypeDef +atlasBaseTypeDefAtlasBaseTypeDef = Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef") + +-- | DSL accessor for the category field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefCategory :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Atlas.TypeCategory) +atlasBaseTypeDefCategory x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the createTime field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefCreateTime :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Schema.DateTime) +atlasBaseTypeDefCreateTime x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the createdBy field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefCreatedBy :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefCreatedBy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefDescription :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the guid field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefGuid :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefGuid x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefName :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefOptions :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (M.Map String String) +atlasBaseTypeDefOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the serviceType field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefServiceType :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefServiceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeVersion field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefTypeVersion :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefTypeVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the updateTime field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefUpdateTime :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Schema.DateTime) +atlasBaseTypeDefUpdateTime x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the updatedBy field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefUpdatedBy :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) +atlasBaseTypeDefUpdatedBy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the version field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefVersion :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe I.Int64) +atlasBaseTypeDefVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the category field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCategory :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Atlas.TypeCategory) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCategory original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the createTime field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCreateTime :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Schema.DateTime) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCreateTime original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the createdBy field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCreatedBy :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithCreatedBy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithDescription :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the guid field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithGuid :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithGuid original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithName :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithOptions :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the serviceType field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithServiceType :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithServiceType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeVersion field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithTypeVersion :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithTypeVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the updateTime field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithUpdateTime :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe Schema.DateTime) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithUpdateTime original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the updatedBy field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithUpdatedBy :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithUpdatedBy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the version field of hydra.ext.atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithVersion :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasBaseTypeDefWithVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "category"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "category")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guid"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "guid")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updatedBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updatedBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "createTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "updateTime"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "updateTime")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "typeVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "serviceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "serviceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasBaseTypeDef"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDef :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm Atlas.AtlasConstraintDef +atlasConstraintDef type_ params = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "params"), + Model.fieldTerm = (Typed.unTypedTerm params)}]})) + +-- | DSL name token for hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDefAtlasConstraintDef :: Typed.TypedName Atlas.AtlasConstraintDef +atlasConstraintDefAtlasConstraintDef = Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasConstraintDef") + +-- | DSL accessor for the params field of hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDefParams :: Typed.TypedTerm Atlas.AtlasConstraintDef -> Typed.TypedTerm (M.Map String String) +atlasConstraintDefParams x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.projectionFieldName = (Model.Name "params")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDefType :: Typed.TypedTerm Atlas.AtlasConstraintDef -> Typed.TypedTerm (Maybe String) +atlasConstraintDefType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the params field of hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDefWithParams :: Typed.TypedTerm Atlas.AtlasConstraintDef -> Typed.TypedTerm (M.Map String String) -> Typed.TypedTerm Atlas.AtlasConstraintDef +atlasConstraintDefWithParams original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "params"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.atlas.AtlasConstraintDef +atlasConstraintDefWithType :: Typed.TypedTerm Atlas.AtlasConstraintDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasConstraintDef +atlasConstraintDefWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "params"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasConstraintDef"), + Model.projectionFieldName = (Model.Name "params")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.atlas.AtlasEntityDef +atlasEntityDef :: Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm [Atlas.AtlasRelationshipAttributeDef] -> Typed.TypedTerm (M.Map String [Atlas.AtlasAttributeDef]) -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDef asAtlasStruct superTypes subTypes relationshipAttributeDefs businessAttributeDefs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Typed.unTypedTerm asAtlasStruct)}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Typed.unTypedTerm superTypes)}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Typed.unTypedTerm subTypes)}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm relationshipAttributeDefs)}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm businessAttributeDefs)}]})) + +-- | DSL accessor for the asAtlasStruct field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefAsAtlasStruct :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm Atlas.AtlasStructDef +atlasEntityDefAsAtlasStruct x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "asAtlasStruct")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.atlas.AtlasEntityDef +atlasEntityDefAtlasEntityDef :: Typed.TypedName Atlas.AtlasEntityDef +atlasEntityDefAtlasEntityDef = Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasEntityDef") + +-- | DSL accessor for the businessAttributeDefs field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefBusinessAttributeDefs :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (M.Map String [Atlas.AtlasAttributeDef]) +atlasEntityDefBusinessAttributeDefs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "businessAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the relationshipAttributeDefs field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefRelationshipAttributeDefs :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm [Atlas.AtlasRelationshipAttributeDef] +atlasEntityDefRelationshipAttributeDefs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "relationshipAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the subTypes field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefSubTypes :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (S.Set String) +atlasEntityDefSubTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "subTypes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the superTypes field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefSuperTypes :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (S.Set String) +atlasEntityDefSuperTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "superTypes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the asAtlasStruct field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefWithAsAtlasStruct :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDefWithAsAtlasStruct original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "superTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "subTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "relationshipAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "businessAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the businessAttributeDefs field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefWithBusinessAttributeDefs :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (M.Map String [Atlas.AtlasAttributeDef]) -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDefWithBusinessAttributeDefs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "asAtlasStruct")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "superTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "subTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "relationshipAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the relationshipAttributeDefs field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefWithRelationshipAttributeDefs :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm [Atlas.AtlasRelationshipAttributeDef] -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDefWithRelationshipAttributeDefs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "asAtlasStruct")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "superTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "subTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "businessAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the subTypes field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefWithSubTypes :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDefWithSubTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "asAtlasStruct")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "superTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "relationshipAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "businessAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the superTypes field of hydra.ext.atlas.AtlasEntityDef +atlasEntityDefWithSuperTypes :: Typed.TypedTerm Atlas.AtlasEntityDef -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm Atlas.AtlasEntityDef +atlasEntityDefWithSuperTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasStruct"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "asAtlasStruct")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "superTypes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "subTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "subTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "relationshipAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "businessAttributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasEntityDef"), + Model.projectionFieldName = (Model.Name "businessAttributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDef :: Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDef asAtlasAttribute relationshipTypeName isLegacyAttribute = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasAttribute"), + Model.fieldTerm = (Typed.unTypedTerm asAtlasAttribute)}, + Model.Field { + Model.fieldName = (Model.Name "relationshipTypeName"), + Model.fieldTerm = (Typed.unTypedTerm relationshipTypeName)}, + Model.Field { + Model.fieldName = (Model.Name "isLegacyAttribute"), + Model.fieldTerm = (Typed.unTypedTerm isLegacyAttribute)}]})) + +-- | DSL accessor for the asAtlasAttribute field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefAsAtlasAttribute :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm Atlas.AtlasAttributeDef +atlasRelationshipAttributeDefAsAtlasAttribute x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "asAtlasAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefAtlasRelationshipAttributeDef :: Typed.TypedName Atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefAtlasRelationshipAttributeDef = + Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef") + +-- | DSL accessor for the isLegacyAttribute field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefIsLegacyAttribute :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm Bool +atlasRelationshipAttributeDefIsLegacyAttribute x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "isLegacyAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the relationshipTypeName field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefRelationshipTypeName :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm (Maybe String) +atlasRelationshipAttributeDefRelationshipTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "relationshipTypeName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the asAtlasAttribute field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithAsAtlasAttribute :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm Atlas.AtlasAttributeDef -> Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithAsAtlasAttribute original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasAttribute"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "relationshipTypeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "relationshipTypeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLegacyAttribute"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "isLegacyAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isLegacyAttribute field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithIsLegacyAttribute :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm Bool -> Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithIsLegacyAttribute original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasAttribute"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "asAtlasAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipTypeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "relationshipTypeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLegacyAttribute"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the relationshipTypeName field of hydra.ext.atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithRelationshipTypeName :: Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Atlas.AtlasRelationshipAttributeDef +atlasRelationshipAttributeDefWithRelationshipTypeName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasAttribute"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "asAtlasAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relationshipTypeName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isLegacyAttribute"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasRelationshipAttributeDef"), + Model.projectionFieldName = (Model.Name "isLegacyAttribute")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.atlas.AtlasStructDef +atlasStructDef :: Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm [Atlas.AtlasAttributeDef] -> Typed.TypedTerm Atlas.AtlasStructDef +atlasStructDef asAtlasBaseType attributeDefs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasBaseType"), + Model.fieldTerm = (Typed.unTypedTerm asAtlasBaseType)}, + Model.Field { + Model.fieldName = (Model.Name "attributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm attributeDefs)}]})) + +-- | DSL accessor for the asAtlasBaseType field of hydra.ext.atlas.AtlasStructDef +atlasStructDefAsAtlasBaseType :: Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm Atlas.AtlasBaseTypeDef +atlasStructDefAsAtlasBaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.projectionFieldName = (Model.Name "asAtlasBaseType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.atlas.AtlasStructDef +atlasStructDefAtlasStructDef :: Typed.TypedName Atlas.AtlasStructDef +atlasStructDefAtlasStructDef = Typed.TypedName (Model.Name "hydra.ext.atlas.AtlasStructDef") + +-- | DSL accessor for the attributeDefs field of hydra.ext.atlas.AtlasStructDef +atlasStructDefAttributeDefs :: Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm [Atlas.AtlasAttributeDef] +atlasStructDefAttributeDefs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.projectionFieldName = (Model.Name "attributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the asAtlasBaseType field of hydra.ext.atlas.AtlasStructDef +atlasStructDefWithAsAtlasBaseType :: Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm Atlas.AtlasBaseTypeDef -> Typed.TypedTerm Atlas.AtlasStructDef +atlasStructDefWithAsAtlasBaseType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasBaseType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "attributeDefs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.projectionFieldName = (Model.Name "attributeDefs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the attributeDefs field of hydra.ext.atlas.AtlasStructDef +atlasStructDefWithAttributeDefs :: Typed.TypedTerm Atlas.AtlasStructDef -> Typed.TypedTerm [Atlas.AtlasAttributeDef] -> Typed.TypedTerm Atlas.AtlasStructDef +atlasStructDefWithAttributeDefs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "asAtlasBaseType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.atlas.AtlasStructDef"), + Model.projectionFieldName = (Model.Name "asAtlasBaseType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributeDefs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the array variant of hydra.ext.atlas.TypeCategory +typeCategoryArray :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the businessMetadata variant of hydra.ext.atlas.TypeCategory +typeCategoryBusinessMetadata :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryBusinessMetadata = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "businessMetadata"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the classification variant of hydra.ext.atlas.TypeCategory +typeCategoryClassification :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryClassification = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "classification"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the entity variant of hydra.ext.atlas.TypeCategory +typeCategoryEntity :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryEntity = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "entity"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the enum variant of hydra.ext.atlas.TypeCategory +typeCategoryEnum :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryEnum = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the map variant of hydra.ext.atlas.TypeCategory +typeCategoryMap :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryMap = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the objectIdType variant of hydra.ext.atlas.TypeCategory +typeCategoryObjectIdType :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryObjectIdType = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "objectIdType"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the primitive variant of hydra.ext.atlas.TypeCategory +typeCategoryPrimitive :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryPrimitive = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primitive"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the relationship variant of hydra.ext.atlas.TypeCategory +typeCategoryRelationship :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryRelationship = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "relationship"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the struct variant of hydra.ext.atlas.TypeCategory +typeCategoryStruct :: Typed.TypedTerm Atlas.TypeCategory +typeCategoryStruct = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.atlas.TypeCategory"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.atlas.TypeCategory +typeCategoryTypeCategory :: Typed.TypedName Atlas.TypeCategory +typeCategoryTypeCategory = Typed.TypedName (Model.Name "hydra.ext.atlas.TypeCategory") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Avro/Environment.hs b/src/main/haskell/Hydra/Ext/Dsl/Avro/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Avro/Environment.hs @@ -0,0 +1,413 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.avro.environment + +module Hydra.Ext.Dsl.Avro.Environment where + +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Avro.Environment as Environment +import qualified Hydra.Ext.Avro.Schema as Schema +import qualified Hydra.Ext.Dsl.Avro.Schema as AvroSchema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.ext.avro.environment.AvroEnvironment +avroEnvironment :: Typed.TypedTerm (M.Map Environment.AvroQualifiedName (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error)) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (M.Map Model.Name Model.Binding) -> Typed.TypedTerm Environment.AvroEnvironment +avroEnvironment namedAdapters namespace elements = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namedAdapters"), + Model.fieldTerm = (Typed.unTypedTerm namedAdapters)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm elements)}]})) + +-- | DSL name token for hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentAvroEnvironment :: Typed.TypedName Environment.AvroEnvironment +avroEnvironmentAvroEnvironment = Typed.TypedName (Model.Name "hydra.ext.avro.environment.AvroEnvironment") + +-- | DSL accessor for the elements field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentElements :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (M.Map Model.Name Model.Binding) +avroEnvironmentElements x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namedAdapters field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentNamedAdapters :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (M.Map Environment.AvroQualifiedName (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error)) +avroEnvironmentNamedAdapters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namedAdapters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespace field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentNamespace :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (Maybe String) +avroEnvironmentNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the elements field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentWithElements :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (M.Map Model.Name Model.Binding) -> Typed.TypedTerm Environment.AvroEnvironment +avroEnvironmentWithElements original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namedAdapters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namedAdapters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the namedAdapters field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentWithNamedAdapters :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (M.Map Environment.AvroQualifiedName (Coders.Adapter Schema.Schema Model.Type JsonModel.Value Model.Term Errors.Error)) -> Typed.TypedTerm Environment.AvroEnvironment +avroEnvironmentWithNamedAdapters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namedAdapters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the namespace field of hydra.ext.avro.environment.AvroEnvironment +avroEnvironmentWithNamespace :: Typed.TypedTerm Environment.AvroEnvironment -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Environment.AvroEnvironment +avroEnvironmentWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namedAdapters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "namedAdapters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroEnvironment"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.environment.AvroForeignKey +avroForeignKey :: Typed.TypedTerm Model.Name -> Typed.TypedTerm (String -> Model.Name) -> Typed.TypedTerm Environment.AvroForeignKey +avroForeignKey typeName constructor = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm typeName)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm constructor)}]})) + +-- | DSL name token for hydra.ext.avro.environment.AvroForeignKey +avroForeignKeyAvroForeignKey :: Typed.TypedName Environment.AvroForeignKey +avroForeignKeyAvroForeignKey = Typed.TypedName (Model.Name "hydra.ext.avro.environment.AvroForeignKey") + +-- | DSL accessor for the constructor field of hydra.ext.avro.environment.AvroForeignKey +avroForeignKeyConstructor :: Typed.TypedTerm Environment.AvroForeignKey -> Typed.TypedTerm (String -> Model.Name) +avroForeignKeyConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeName field of hydra.ext.avro.environment.AvroForeignKey +avroForeignKeyTypeName :: Typed.TypedTerm Environment.AvroForeignKey -> Typed.TypedTerm Model.Name +avroForeignKeyTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constructor field of hydra.ext.avro.environment.AvroForeignKey +avroForeignKeyWithConstructor :: Typed.TypedTerm Environment.AvroForeignKey -> Typed.TypedTerm (String -> Model.Name) -> Typed.TypedTerm Environment.AvroForeignKey +avroForeignKeyWithConstructor original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the typeName field of hydra.ext.avro.environment.AvroForeignKey +avroForeignKeyWithTypeName :: Typed.TypedTerm Environment.AvroForeignKey -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Environment.AvroForeignKey +avroForeignKeyWithTypeName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroForeignKey"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKey :: Typed.TypedTerm Model.Name -> Typed.TypedTerm (String -> Model.Name) -> Typed.TypedTerm Environment.AvroPrimaryKey +avroPrimaryKey fieldName constructor = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fieldName"), + Model.fieldTerm = (Typed.unTypedTerm fieldName)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm constructor)}]})) + +-- | DSL name token for hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKeyAvroPrimaryKey :: Typed.TypedName Environment.AvroPrimaryKey +avroPrimaryKeyAvroPrimaryKey = Typed.TypedName (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey") + +-- | DSL accessor for the constructor field of hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKeyConstructor :: Typed.TypedTerm Environment.AvroPrimaryKey -> Typed.TypedTerm (String -> Model.Name) +avroPrimaryKeyConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the fieldName field of hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKeyFieldName :: Typed.TypedTerm Environment.AvroPrimaryKey -> Typed.TypedTerm Model.Name +avroPrimaryKeyFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.projectionFieldName = (Model.Name "fieldName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constructor field of hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKeyWithConstructor :: Typed.TypedTerm Environment.AvroPrimaryKey -> Typed.TypedTerm (String -> Model.Name) -> Typed.TypedTerm Environment.AvroPrimaryKey +avroPrimaryKeyWithConstructor original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fieldName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.projectionFieldName = (Model.Name "fieldName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the fieldName field of hydra.ext.avro.environment.AvroPrimaryKey +avroPrimaryKeyWithFieldName :: Typed.TypedTerm Environment.AvroPrimaryKey -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Environment.AvroPrimaryKey +avroPrimaryKeyWithFieldName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fieldName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroPrimaryKey"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedName :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm String -> Typed.TypedTerm Environment.AvroQualifiedName +avroQualifiedName namespace name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL name token for hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedNameAvroQualifiedName :: Typed.TypedName Environment.AvroQualifiedName +avroQualifiedNameAvroQualifiedName = Typed.TypedName (Model.Name "hydra.ext.avro.environment.AvroQualifiedName") + +-- | DSL accessor for the name field of hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedNameName :: Typed.TypedTerm Environment.AvroQualifiedName -> Typed.TypedTerm String +avroQualifiedNameName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespace field of hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedNameNamespace :: Typed.TypedTerm Environment.AvroQualifiedName -> Typed.TypedTerm (Maybe String) +avroQualifiedNameNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedNameWithName :: Typed.TypedTerm Environment.AvroQualifiedName -> Typed.TypedTerm String -> Typed.TypedTerm Environment.AvroQualifiedName +avroQualifiedNameWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the namespace field of hydra.ext.avro.environment.AvroQualifiedName +avroQualifiedNameWithNamespace :: Typed.TypedTerm Environment.AvroQualifiedName -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Environment.AvroQualifiedName +avroQualifiedNameWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.AvroQualifiedName"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironment :: Typed.TypedTerm (M.Map Model.Name Model.Type) -> Typed.TypedTerm (M.Map Model.Name (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error)) -> Typed.TypedTerm Environment.EncodeEnvironment +encodeEnvironment typeMap emitted = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeMap"), + Model.fieldTerm = (Typed.unTypedTerm typeMap)}, + Model.Field { + Model.fieldName = (Model.Name "emitted"), + Model.fieldTerm = (Typed.unTypedTerm emitted)}]})) + +-- | DSL accessor for the emitted field of hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironmentEmitted :: Typed.TypedTerm Environment.EncodeEnvironment -> Typed.TypedTerm (M.Map Model.Name (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error)) +encodeEnvironmentEmitted x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.projectionFieldName = (Model.Name "emitted")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironmentEncodeEnvironment :: Typed.TypedName Environment.EncodeEnvironment +encodeEnvironmentEncodeEnvironment = Typed.TypedName (Model.Name "hydra.ext.avro.environment.EncodeEnvironment") + +-- | DSL accessor for the typeMap field of hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironmentTypeMap :: Typed.TypedTerm Environment.EncodeEnvironment -> Typed.TypedTerm (M.Map Model.Name Model.Type) +encodeEnvironmentTypeMap x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.projectionFieldName = (Model.Name "typeMap")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the emitted field of hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironmentWithEmitted :: Typed.TypedTerm Environment.EncodeEnvironment -> Typed.TypedTerm (M.Map Model.Name (Coders.Adapter Model.Type Schema.Schema Model.Term JsonModel.Value Errors.Error)) -> Typed.TypedTerm Environment.EncodeEnvironment +encodeEnvironmentWithEmitted original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeMap"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.projectionFieldName = (Model.Name "typeMap")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "emitted"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the typeMap field of hydra.ext.avro.environment.EncodeEnvironment +encodeEnvironmentWithTypeMap :: Typed.TypedTerm Environment.EncodeEnvironment -> Typed.TypedTerm (M.Map Model.Name Model.Type) -> Typed.TypedTerm Environment.EncodeEnvironment +encodeEnvironmentWithTypeMap original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeMap"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "emitted"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.environment.EncodeEnvironment"), + Model.projectionFieldName = (Model.Name "emitted")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Avro/Schema.hs b/src/main/haskell/Hydra/Ext/Dsl/Avro/Schema.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Avro/Schema.hs @@ -0,0 +1,1241 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.avro.schema + +module Hydra.Ext.Dsl.Avro.Schema where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Avro.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.ext.avro.schema.Array +array :: Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Array +array items = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Array"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "items"), + Model.fieldTerm = (Typed.unTypedTerm items)}]})) + +-- | DSL name token for hydra.ext.avro.schema.Array +arrayArray :: Typed.TypedName Schema.Array +arrayArray = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Array") + +-- | DSL accessor for the items field of hydra.ext.avro.schema.Array +arrayItems :: Typed.TypedTerm Schema.Array -> Typed.TypedTerm Schema.Schema +arrayItems x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Array"), + Model.projectionFieldName = (Model.Name "items")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the items field of hydra.ext.avro.schema.Array +arrayWithItems :: Typed.TypedTerm Schema.Array -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Array +arrayWithItems original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Array"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "items"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.avro.schema.Enum +enum :: Typed.TypedTerm [String] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Enum +enum symbols default_ = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "symbols"), + Model.fieldTerm = (Typed.unTypedTerm symbols)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm default_)}]})) + +-- | DSL accessor for the default field of hydra.ext.avro.schema.Enum +enumDefault :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm (Maybe String) +enumDefault x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.schema.Enum +enumEnum :: Typed.TypedName Schema.Enum +enumEnum = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Enum") + +-- | DSL accessor for the symbols field of hydra.ext.avro.schema.Enum +enumSymbols :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm [String] +enumSymbols x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.projectionFieldName = (Model.Name "symbols")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the default field of hydra.ext.avro.schema.Enum +enumWithDefault :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Enum +enumWithDefault original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "symbols"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.projectionFieldName = (Model.Name "symbols")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the symbols field of hydra.ext.avro.schema.Enum +enumWithSymbols :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm [String] -> Typed.TypedTerm Schema.Enum +enumWithSymbols original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "symbols"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.schema.Field +field :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm (Maybe Schema.Order) -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Field +field name doc type_ default_ order aliases annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm doc)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm default_)}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Typed.unTypedTerm order)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm aliases)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the aliases field of hydra.ext.avro.schema.Field +fieldAliases :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe [String]) +fieldAliases x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the annotations field of hydra.ext.avro.schema.Field +fieldAnnotations :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (M.Map String JsonModel.Value) +fieldAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the default field of hydra.ext.avro.schema.Field +fieldDefault :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe JsonModel.Value) +fieldDefault x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the doc field of hydra.ext.avro.schema.Field +fieldDoc :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe String) +fieldDoc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.schema.Field +fieldField :: Typed.TypedName Schema.Field +fieldField = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Field") + +-- | DSL accessor for the name field of hydra.ext.avro.schema.Field +fieldName :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm String +fieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the order field of hydra.ext.avro.schema.Field +fieldOrder :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe Schema.Order) +fieldOrder x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.avro.schema.Field +fieldType :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm Schema.Schema +fieldType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the aliases field of hydra.ext.avro.schema.Field +fieldWithAliases :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Schema.Field +fieldWithAliases original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the annotations field of hydra.ext.avro.schema.Field +fieldWithAnnotations :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Field +fieldWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the default field of hydra.ext.avro.schema.Field +fieldWithDefault :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Schema.Field +fieldWithDefault original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the doc field of hydra.ext.avro.schema.Field +fieldWithDoc :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Field +fieldWithDoc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.avro.schema.Field +fieldWithName :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Field +fieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the order field of hydra.ext.avro.schema.Field +fieldWithOrder :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe Schema.Order) -> Typed.TypedTerm Schema.Field +fieldWithOrder original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.avro.schema.Field +fieldWithType :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Field +fieldWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.schema.Fixed +fixed :: Typed.TypedTerm Int -> Typed.TypedTerm Schema.Fixed +fixed size = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Fixed"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "size"), + Model.fieldTerm = (Typed.unTypedTerm size)}]})) + +-- | DSL name token for hydra.ext.avro.schema.Fixed +fixedFixed :: Typed.TypedName Schema.Fixed +fixedFixed = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Fixed") + +-- | DSL accessor for the size field of hydra.ext.avro.schema.Fixed +fixedSize :: Typed.TypedTerm Schema.Fixed -> Typed.TypedTerm Int +fixedSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Fixed"), + Model.projectionFieldName = (Model.Name "size")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the size field of hydra.ext.avro.schema.Fixed +fixedWithSize :: Typed.TypedTerm Schema.Fixed -> Typed.TypedTerm Int -> Typed.TypedTerm Schema.Fixed +fixedWithSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Fixed"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "size"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.avro.schema.Map +map :: Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Map +map values = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm values)}]})) + +-- | DSL name token for hydra.ext.avro.schema.Map +mapMap :: Typed.TypedName Schema.Map +mapMap = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Map") + +-- | DSL accessor for the values field of hydra.ext.avro.schema.Map +mapValues :: Typed.TypedTerm Schema.Map -> Typed.TypedTerm Schema.Schema +mapValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Map"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the values field of hydra.ext.avro.schema.Map +mapWithValues :: Typed.TypedTerm Schema.Map -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Map +mapWithValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.avro.schema.Named +named :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.NamedType -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Named +named name namespace aliases doc type_ annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm aliases)}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm doc)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the aliases field of hydra.ext.avro.schema.Named +namedAliases :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe [String]) +namedAliases x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the annotations field of hydra.ext.avro.schema.Named +namedAnnotations :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (M.Map String JsonModel.Value) +namedAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the doc field of hydra.ext.avro.schema.Named +namedDoc :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) +namedDoc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.avro.schema.Named +namedName :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm String +namedName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.schema.Named +namedNamed :: Typed.TypedName Schema.Named +namedNamed = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Named") + +-- | DSL accessor for the namespace field of hydra.ext.avro.schema.Named +namedNamespace :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) +namedNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.avro.schema.Named +namedType :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm Schema.NamedType +namedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the enum variant of hydra.ext.avro.schema.NamedType +namedTypeEnum :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm Schema.NamedType +namedTypeEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the fixed variant of hydra.ext.avro.schema.NamedType +namedTypeFixed :: Typed.TypedTerm Schema.Fixed -> Typed.TypedTerm Schema.NamedType +namedTypeFixed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.avro.schema.NamedType +namedTypeNamedType :: Typed.TypedName Schema.NamedType +namedTypeNamedType = Typed.TypedName (Model.Name "hydra.ext.avro.schema.NamedType") + +-- | DSL injection for the record variant of hydra.ext.avro.schema.NamedType +namedTypeRecord :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm Schema.NamedType +namedTypeRecord x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "record"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the aliases field of hydra.ext.avro.schema.Named +namedWithAliases :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Schema.Named +namedWithAliases original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the annotations field of hydra.ext.avro.schema.Named +namedWithAnnotations :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Named +namedWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the doc field of hydra.ext.avro.schema.Named +namedWithDoc :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Named +namedWithDoc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.avro.schema.Named +namedWithName :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Named +namedWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the namespace field of hydra.ext.avro.schema.Named +namedWithNamespace :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Named +namedWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.avro.schema.Named +namedWithType :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm Schema.NamedType -> Typed.TypedTerm Schema.Named +namedWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the ascending variant of hydra.ext.avro.schema.Order +orderAscending :: Typed.TypedTerm Schema.Order +orderAscending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ascending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the descending variant of hydra.ext.avro.schema.Order +orderDescending :: Typed.TypedTerm Schema.Order +orderDescending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ignore variant of hydra.ext.avro.schema.Order +orderIgnore :: Typed.TypedTerm Schema.Order +orderIgnore = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ignore"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.avro.schema.Order +orderOrder :: Typed.TypedName Schema.Order +orderOrder = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Order") + +-- | DSL injection for the boolean variant of hydra.ext.avro.schema.Primitive +primitiveBoolean :: Typed.TypedTerm Schema.Primitive +primitiveBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bytes variant of hydra.ext.avro.schema.Primitive +primitiveBytes :: Typed.TypedTerm Schema.Primitive +primitiveBytes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bytes"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.avro.schema.Primitive +primitiveDouble :: Typed.TypedTerm Schema.Primitive +primitiveDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.avro.schema.Primitive +primitiveFloat :: Typed.TypedTerm Schema.Primitive +primitiveFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int variant of hydra.ext.avro.schema.Primitive +primitiveInt :: Typed.TypedTerm Schema.Primitive +primitiveInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the long variant of hydra.ext.avro.schema.Primitive +primitiveLong :: Typed.TypedTerm Schema.Primitive +primitiveLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the null variant of hydra.ext.avro.schema.Primitive +primitiveNull :: Typed.TypedTerm Schema.Primitive +primitiveNull = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.avro.schema.Primitive +primitivePrimitive :: Typed.TypedName Schema.Primitive +primitivePrimitive = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Primitive") + +-- | DSL injection for the string variant of hydra.ext.avro.schema.Primitive +primitiveString :: Typed.TypedTerm Schema.Primitive +primitiveString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.avro.schema.Record +record :: Typed.TypedTerm [Schema.Field] -> Typed.TypedTerm Schema.Record +record fields = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Record"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}]})) + +-- | DSL accessor for the fields field of hydra.ext.avro.schema.Record +recordFields :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm [Schema.Field] +recordFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Record"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.schema.Record +recordRecord :: Typed.TypedName Schema.Record +recordRecord = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Record") + +-- | DSL updater for the fields field of hydra.ext.avro.schema.Record +recordWithFields :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm [Schema.Field] -> Typed.TypedTerm Schema.Record +recordWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Record"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the array variant of hydra.ext.avro.schema.Schema +schemaArray :: Typed.TypedTerm Schema.Array -> Typed.TypedTerm Schema.Schema +schemaArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.avro.schema.Schema +schemaMap :: Typed.TypedTerm Schema.Map -> Typed.TypedTerm Schema.Schema +schemaMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the named variant of hydra.ext.avro.schema.Schema +schemaNamed :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm Schema.Schema +schemaNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the primitive variant of hydra.ext.avro.schema.Schema +schemaPrimitive :: Typed.TypedTerm Schema.Primitive -> Typed.TypedTerm Schema.Schema +schemaPrimitive x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primitive"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the reference variant of hydra.ext.avro.schema.Schema +schemaReference :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema +schemaReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.avro.schema.Schema +schemaSchema :: Typed.TypedName Schema.Schema +schemaSchema = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Schema") + +-- | DSL injection for the union variant of hydra.ext.avro.schema.Schema +schemaUnion :: Typed.TypedTerm Schema.Union -> Typed.TypedTerm Schema.Schema +schemaUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the body of hydra.ext.avro.schema.Union +unUnion :: Typed.TypedTerm Schema.Union -> Typed.TypedTerm [Schema.Schema] +unUnion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.avro.schema.Union")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.avro.schema.Union wrapper +union :: Typed.TypedTerm [Schema.Schema] -> Typed.TypedTerm Schema.Union +union x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.avro.schema.Union"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.schema.Union +unionUnion :: Typed.TypedName Schema.Union +unionUnion = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Union") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Avro/Testing.hs b/src/main/haskell/Hydra/Ext/Dsl/Avro/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Avro/Testing.hs @@ -0,0 +1,2090 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.avro.testing + +module Hydra.Ext.Dsl.Avro.Testing where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Avro.Schema as Schema +import qualified Hydra.Ext.Avro.Testing as Testing +import qualified Hydra.Ext.Dsl.Avro.Schema as AvroSchema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL name token for hydra.ext.avro.testing.AvroTestCase +avroTestCaseAvroTestCase :: Typed.TypedName Testing.AvroTestCase +avroTestCaseAvroTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.AvroTestCase") + +-- | DSL injection for the lossiness variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseLossiness :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseLossiness x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lossiness"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nameMapping variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseNameMapping :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseNameMapping x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nameMapping"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the schemaSerialization variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseSchemaSerialization :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseSchemaSerialization x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "schemaSerialization"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the termLevelForward variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTermLevelForward :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTermLevelForward x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "termLevelForward"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the termLevelReverse variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTermLevelReverse :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTermLevelReverse x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "termLevelReverse"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the termLevelRoundTripJson variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTermLevelRoundTripJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTermLevelRoundTripJson x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "termLevelRoundTripJson"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the termLevelRoundTripTerm variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTermLevelRoundTripTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTermLevelRoundTripTerm x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "termLevelRoundTripTerm"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeLevelForward variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTypeLevelForward :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTypeLevelForward x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeLevelForward"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeLevelReverse variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTypeLevelReverse :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTypeLevelReverse x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeLevelReverse"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeLevelRoundTripAvro variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTypeLevelRoundTripAvro :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTypeLevelRoundTripAvro x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeLevelRoundTripAvro"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeLevelRoundTripHydra variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseTypeLevelRoundTripHydra :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseTypeLevelRoundTripHydra x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeLevelRoundTripHydra"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the union variant of hydra.ext.avro.testing.AvroTestCase +avroTestCaseUnion :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Testing.AvroTestCase +avroTestCaseUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.avro.testing.LossinessTestCase +lossinessTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Bool -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCase description originalSchema hydraType recoveredSchema isLossy = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Typed.unTypedTerm originalSchema)}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Typed.unTypedTerm hydraType)}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Typed.unTypedTerm recoveredSchema)}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Typed.unTypedTerm isLossy)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseDescription :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm String +lossinessTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hydraType field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseHydraType :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Model.Type +lossinessTestCaseHydraType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isLossy field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseIsLossy :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Bool +lossinessTestCaseIsLossy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "isLossy")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseLossinessTestCase :: Typed.TypedName Testing.LossinessTestCase +lossinessTestCaseLossinessTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.LossinessTestCase") + +-- | DSL accessor for the originalSchema field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseOriginalSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema +lossinessTestCaseOriginalSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "originalSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the recoveredSchema field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseRecoveredSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema +lossinessTestCaseRecoveredSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "recoveredSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the description field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseWithDescription :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "originalSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "recoveredSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "isLossy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hydraType field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseWithHydraType :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCaseWithHydraType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "originalSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "recoveredSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "isLossy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isLossy field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseWithIsLossy :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Bool -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCaseWithIsLossy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "originalSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "recoveredSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the originalSchema field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseWithOriginalSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCaseWithOriginalSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "recoveredSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "isLossy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the recoveredSchema field of hydra.ext.avro.testing.LossinessTestCase +lossinessTestCaseWithRecoveredSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.LossinessTestCase +lossinessTestCaseWithRecoveredSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "originalSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "originalSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "recoveredSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isLossy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"), + Model.projectionFieldName = (Model.Name "isLossy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Name -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.NameMappingTestCase +nameMappingTestCase description hydraName avroName avroNamespace = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "hydraName"), + Model.fieldTerm = (Typed.unTypedTerm hydraName)}, + Model.Field { + Model.fieldName = (Model.Name "avroName"), + Model.fieldTerm = (Typed.unTypedTerm avroName)}, + Model.Field { + Model.fieldName = (Model.Name "avroNamespace"), + Model.fieldTerm = (Typed.unTypedTerm avroNamespace)}]})) + +-- | DSL accessor for the avroName field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseAvroName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String +nameMappingTestCaseAvroName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the avroNamespace field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseAvroNamespace :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm (Maybe String) +nameMappingTestCaseAvroNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroNamespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseDescription :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String +nameMappingTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hydraName field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseHydraName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Model.Name +nameMappingTestCaseHydraName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "hydraName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseNameMappingTestCase :: Typed.TypedName Testing.NameMappingTestCase +nameMappingTestCaseNameMappingTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.NameMappingTestCase") + +-- | DSL updater for the avroName field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseWithAvroName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.NameMappingTestCase +nameMappingTestCaseWithAvroName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "hydraName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "avroNamespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroNamespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the avroNamespace field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseWithAvroNamespace :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.NameMappingTestCase +nameMappingTestCaseWithAvroNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "hydraName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroNamespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the description field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseWithDescription :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.NameMappingTestCase +nameMappingTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hydraName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "hydraName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroNamespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroNamespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hydraName field of hydra.ext.avro.testing.NameMappingTestCase +nameMappingTestCaseWithHydraName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Testing.NameMappingTestCase +nameMappingTestCaseWithHydraName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "avroName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroNamespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"), + Model.projectionFieldName = (Model.Name "avroNamespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.SchemaSerializationTestCase +schemaSerializationTestCase description schema json = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm json)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseDescription :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm String +schemaSerializationTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the json field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseJson :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm JsonModel.Value +schemaSerializationTestCaseJson x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseSchema :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Schema.Schema +schemaSerializationTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseSchemaSerializationTestCase :: Typed.TypedName Testing.SchemaSerializationTestCase +schemaSerializationTestCaseSchemaSerializationTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithDescription :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the json field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithJson :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithJson original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithSchema :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.SchemaSerializationTestCase +schemaSerializationTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelForwardTestCase +termLevelForwardTestCase description schema json term = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm json)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm term)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseDescription :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm String +termLevelForwardTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseJson :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm JsonModel.Value +termLevelForwardTestCaseJson x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseSchema :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Schema.Schema +termLevelForwardTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseTerm :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Model.Term +termLevelForwardTestCaseTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseTermLevelForwardTestCase :: Typed.TypedName Testing.TermLevelForwardTestCase +termLevelForwardTestCaseTermLevelForwardTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithJson original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelForwardTestCase +termLevelForwardTestCaseWithTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Term -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelReverseTestCase +termLevelReverseTestCase description schema term json = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm term)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm json)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseDescription :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm String +termLevelReverseTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseJson :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm JsonModel.Value +termLevelReverseTestCaseJson x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseSchema :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Schema.Schema +termLevelReverseTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseTerm :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Model.Term +termLevelReverseTestCaseTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseTermLevelReverseTestCase :: Typed.TypedName Testing.TermLevelReverseTestCase +termLevelReverseTestCaseTermLevelReverseTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithJson original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelReverseTestCase +termLevelReverseTestCaseWithTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCase description schema json expectedJson = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm json)}, + Model.Field { + Model.fieldName = (Model.Name "expectedJson"), + Model.fieldTerm = (Typed.unTypedTerm expectedJson)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseDescription :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm String +termLevelRoundTripJsonTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expectedJson field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseExpectedJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value +termLevelRoundTripJsonTestCaseExpectedJson x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "expectedJson")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value +termLevelRoundTripJsonTestCaseJson x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseSchema :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Schema.Schema +termLevelRoundTripJsonTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseTermLevelRoundTripJsonTestCase :: Typed.TypedName Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseTermLevelRoundTripJsonTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedJson"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "expectedJson")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expectedJson field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithExpectedJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithExpectedJson original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedJson"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithJson original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expectedJson"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "expectedJson")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase +termLevelRoundTripJsonTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "json")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedJson"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"), + Model.projectionFieldName = (Model.Name "expectedJson")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCase description type_ term expectedTerm = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm term)}, + Model.Field { + Model.fieldName = (Model.Name "expectedTerm"), + Model.fieldTerm = (Typed.unTypedTerm expectedTerm)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseDescription :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm String +termLevelRoundTripTermTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expectedTerm field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseExpectedTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term +termLevelRoundTripTermTestCaseExpectedTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "expectedTerm")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term +termLevelRoundTripTermTestCaseTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseTermLevelRoundTripTermTestCase :: Typed.TypedName Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseTermLevelRoundTripTermTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase") + +-- | DSL accessor for the type field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseType :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Type +termLevelRoundTripTermTestCaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedTerm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "expectedTerm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expectedTerm field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithExpectedTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithExpectedTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedTerm"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expectedTerm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "expectedTerm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithType :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase +termLevelRoundTripTermTestCaseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedTerm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"), + Model.projectionFieldName = (Model.Name "expectedTerm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelForwardTestCase +typeLevelForwardTestCase description schema type_ = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm String +typeLevelForwardTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Schema.Schema +typeLevelForwardTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseType :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Model.Type +typeLevelForwardTestCaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseTypeLevelForwardTestCase :: Typed.TypedName Testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseTypeLevelForwardTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelForwardTestCase +typeLevelForwardTestCaseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelReverseTestCase +typeLevelReverseTestCase description type_ schema = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm String +typeLevelReverseTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Schema.Schema +typeLevelReverseTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseType :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Model.Type +typeLevelReverseTestCaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseTypeLevelReverseTestCase :: Typed.TypedName Testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseTypeLevelReverseTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelReverseTestCase +typeLevelReverseTestCaseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCase description schema expectedSchema = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "expectedSchema"), + Model.fieldTerm = (Typed.unTypedTerm expectedSchema)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm String +typeLevelRoundTripAvroTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expectedSchema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseExpectedSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema +typeLevelRoundTripAvroTestCaseExpectedSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "expectedSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema +typeLevelRoundTripAvroTestCaseSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseTypeLevelRoundTripAvroTestCase :: Typed.TypedName Testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseTypeLevelRoundTripAvroTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "expectedSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expectedSchema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithExpectedSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithExpectedSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase +typeLevelRoundTripAvroTestCaseWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expectedSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"), + Model.projectionFieldName = (Model.Name "expectedSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCase description type_ expectedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "expectedType"), + Model.fieldTerm = (Typed.unTypedTerm expectedType)}]})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm String +typeLevelRoundTripHydraTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expectedType field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseExpectedType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type +typeLevelRoundTripHydraTestCaseExpectedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "expectedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type +typeLevelRoundTripHydraTestCaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseTypeLevelRoundTripHydraTestCase :: Typed.TypedName Testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseTypeLevelRoundTripHydraTestCase = + Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase") + +-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "expectedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expectedType field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithExpectedType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithExpectedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expectedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase +typeLevelRoundTripHydraTestCaseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expectedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"), + Model.projectionFieldName = (Model.Name "expectedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.avro.testing.UnionTestCase +unionTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm [(Model.Term, JsonModel.Value)] -> Typed.TypedTerm Testing.UnionTestCase +unionTestCase description hydraType avroSchema termPairs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Typed.unTypedTerm hydraType)}, + Model.Field { + Model.fieldName = (Model.Name "avroSchema"), + Model.fieldTerm = (Typed.unTypedTerm avroSchema)}, + Model.Field { + Model.fieldName = (Model.Name "termPairs"), + Model.fieldTerm = (Typed.unTypedTerm termPairs)}]})) + +-- | DSL accessor for the avroSchema field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseAvroSchema :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Schema.Schema +unionTestCaseAvroSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "avroSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseDescription :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm String +unionTestCaseDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hydraType field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseHydraType :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Model.Type +unionTestCaseHydraType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the termPairs field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseTermPairs :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm [(Model.Term, JsonModel.Value)] +unionTestCaseTermPairs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "termPairs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.avro.testing.UnionTestCase +unionTestCaseUnionTestCase :: Typed.TypedName Testing.UnionTestCase +unionTestCaseUnionTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.UnionTestCase") + +-- | DSL updater for the avroSchema field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseWithAvroSchema :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.UnionTestCase +unionTestCaseWithAvroSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "termPairs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "termPairs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseWithDescription :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.UnionTestCase +unionTestCaseWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "avroSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "termPairs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "termPairs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hydraType field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseWithHydraType :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.UnionTestCase +unionTestCaseWithHydraType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "avroSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "avroSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "termPairs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "termPairs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the termPairs field of hydra.ext.avro.testing.UnionTestCase +unionTestCaseWithTermPairs :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm [(Model.Term, JsonModel.Value)] -> Typed.TypedTerm Testing.UnionTestCase +unionTestCaseWithTermPairs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "hydraType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "avroSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"), + Model.projectionFieldName = (Model.Name "avroSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "termPairs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Azure/Dtld.hs b/src/main/haskell/Hydra/Ext/Dsl/Azure/Dtld.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Azure/Dtld.hs @@ -0,0 +1,8206 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.azure.dtld + +module Hydra.Ext.Dsl.Azure.Dtld where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Azure.Dtld as Dtld +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | DSL constructor for hydra.ext.azure.dtld.Command +command :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.CommandType) -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command +command type_ name id comment description displayName commandType request response = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Typed.unTypedTerm commandType)}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Typed.unTypedTerm request)}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Typed.unTypedTerm response)}]})) + +-- | DSL name token for hydra.ext.azure.dtld.Command +commandCommand :: Typed.TypedName Dtld.Command +commandCommand = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Command") + +-- | DSL accessor for the commandType field of hydra.ext.azure.dtld.Command +commandCommandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandType) +commandCommandType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Command +commandComment :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) +commandComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Command +commandDescription :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) +commandDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Command +commandDisplayName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) +commandDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Command +commandId :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.Dtmi) +commandId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Command +commandName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm String +commandName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.azure.dtld.CommandPayload +commandPayload :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload +commandPayload name schema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL name token for hydra.ext.azure.dtld.CommandPayload +commandPayloadCommandPayload :: Typed.TypedName Dtld.CommandPayload +commandPayloadCommandPayload = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.CommandPayload") + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.CommandPayload +commandPayloadComment :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) +commandPayloadComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.CommandPayload +commandPayloadDescription :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) +commandPayloadDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.CommandPayload +commandPayloadDisplayName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) +commandPayloadDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.CommandPayload +commandPayloadId :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe Dtld.Dtmi) +commandPayloadId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.CommandPayload +commandPayloadName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm String +commandPayloadName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.CommandPayload +commandPayloadSchema :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm Dtld.Schema +commandPayloadSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithComment :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithDescription :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithDisplayName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithId :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.CommandPayload +commandPayloadWithSchema :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.CommandPayload +commandPayloadWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the request field of hydra.ext.azure.dtld.Command +commandRequest :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) +commandRequest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the response field of hydra.ext.azure.dtld.Command +commandResponse :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) +commandResponse x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Command +commandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.Iri +commandType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the asynchronous variant of hydra.ext.azure.dtld.CommandType +commandTypeAsynchronous :: Typed.TypedTerm Dtld.CommandType +commandTypeAsynchronous = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "asynchronous"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.azure.dtld.CommandType +commandTypeCommandType :: Typed.TypedName Dtld.CommandType +commandTypeCommandType = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.CommandType") + +-- | DSL injection for the synchronous variant of hydra.ext.azure.dtld.CommandType +commandTypeSynchronous :: Typed.TypedTerm Dtld.CommandType +commandTypeSynchronous = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "synchronous"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL updater for the commandType field of hydra.ext.azure.dtld.Command +commandWithCommandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandType) -> Typed.TypedTerm Dtld.Command +commandWithCommandType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Command +commandWithComment :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command +commandWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Command +commandWithDescription :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command +commandWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Command +commandWithDisplayName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command +commandWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Command +commandWithId :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Command +commandWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Command +commandWithName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Command +commandWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the request field of hydra.ext.azure.dtld.Command +commandWithRequest :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command +commandWithRequest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the response field of hydra.ext.azure.dtld.Command +commandWithResponse :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command +commandWithResponse original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Command +commandWithType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Command +commandWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commandType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "commandType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "request"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "request")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "response"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"), + Model.projectionFieldName = (Model.Name "response")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.Component +component :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component +component type_ name schema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Component +componentComment :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) +componentComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Component +componentComponent :: Typed.TypedName Dtld.Component +componentComponent = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Component") + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Component +componentDescription :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) +componentDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Component +componentDisplayName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) +componentDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Component +componentId :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe Dtld.Dtmi) +componentId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Component +componentName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm String +componentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.Component +componentSchema :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Interface +componentSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Component +componentType :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Iri +componentType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Component +componentWithComment :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component +componentWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Component +componentWithDescription :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component +componentWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Component +componentWithDisplayName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component +componentWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Component +componentWithId :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Component +componentWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Component +componentWithName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Component +componentWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.Component +componentWithSchema :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Component +componentWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Component +componentWithType :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Component +componentWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.azure.dtld.Dtmi wrapper +dtmi :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Dtmi +dtmi x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Dtmi"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Dtmi +dtmiDtmi :: Typed.TypedName Dtld.Dtmi +dtmiDtmi = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Dtmi") + +-- | DSL constructor for hydra.ext.azure.dtld.EnumValue +enumValue :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue +enumValue name enumValue id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Typed.unTypedTerm enumValue)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.EnumValue +enumValueComment :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) +enumValueComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.EnumValue +enumValueDescription :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) +enumValueDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.EnumValue +enumValueDisplayName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) +enumValueDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.EnumValue +enumValueEnumValue :: Typed.TypedName Dtld.EnumValue +enumValueEnumValue = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.EnumValue") + +-- | DSL accessor for the enumValue field of hydra.ext.azure.dtld.EnumValue +enumValueEnumValue2 :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm Dtld.IntegerOrString +enumValueEnumValue2 x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.EnumValue +enumValueId :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) +enumValueId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.EnumValue +enumValueName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm String +enumValueName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.EnumValue +enumValueWithComment :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue +enumValueWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.EnumValue +enumValueWithDescription :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue +enumValueWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.EnumValue +enumValueWithDisplayName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue +enumValueWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the enumValue field of hydra.ext.azure.dtld.EnumValue +enumValueWithEnumValue :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm Dtld.EnumValue +enumValueWithEnumValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.EnumValue +enumValueWithId :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.EnumValue +enumValueWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.EnumValue +enumValueWithName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.EnumValue +enumValueWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "enumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "enumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.Field +field :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field +field name schema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Field +fieldComment :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) +fieldComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Field +fieldDescription :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) +fieldDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Field +fieldDisplayName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) +fieldDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Field +fieldField :: Typed.TypedName Dtld.Field +fieldField = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Field") + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Field +fieldId :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe Dtld.Dtmi) +fieldId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Field +fieldName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm String +fieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.Field +fieldSchema :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm Dtld.Schema +fieldSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Field +fieldWithComment :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field +fieldWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Field +fieldWithDescription :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field +fieldWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Field +fieldWithDisplayName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field +fieldWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Field +fieldWithId :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Field +fieldWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Field +fieldWithName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Field +fieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.Field +fieldWithSchema :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Field +fieldWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the integer variant of hydra.ext.azure.dtld.IntegerOrString +integerOrStringInteger :: Typed.TypedTerm Int -> Typed.TypedTerm Dtld.IntegerOrString +integerOrStringInteger x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.IntegerOrString"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.azure.dtld.IntegerOrString +integerOrStringIntegerOrString :: Typed.TypedName Dtld.IntegerOrString +integerOrStringIntegerOrString = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.IntegerOrString") + +-- | DSL injection for the string variant of hydra.ext.azure.dtld.IntegerOrString +integerOrStringString :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.IntegerOrString +integerOrStringString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.IntegerOrString"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.azure.dtld.Interface +interface :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents)) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface)) -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface)) -> Typed.TypedTerm Dtld.Interface +interface id type_ context comment contents description displayName extends schemas = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Typed.unTypedTerm context)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Typed.unTypedTerm contents)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Typed.unTypedTerm extends)}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Typed.unTypedTerm schemas)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Interface +interfaceComment :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) +interfaceComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the contents field of hydra.ext.azure.dtld.Interface +interfaceContents :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents)) +interfaceContents x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the command variant of hydra.ext.azure.dtld.InterfaceContents +interfaceContentsCommand :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.InterfaceContents +interfaceContentsCommand x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "command"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the component variant of hydra.ext.azure.dtld.InterfaceContents +interfaceContentsComponent :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.InterfaceContents +interfaceContentsComponent x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "component"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.azure.dtld.InterfaceContents +interfaceContentsInterfaceContents :: Typed.TypedName Dtld.InterfaceContents +interfaceContentsInterfaceContents = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.InterfaceContents") + +-- | DSL injection for the property variant of hydra.ext.azure.dtld.InterfaceContents +interfaceContentsProperty :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.InterfaceContents +interfaceContentsProperty x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the relationship variant of hydra.ext.azure.dtld.InterfaceContents +interfaceContentsRelationship :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.InterfaceContents +interfaceContentsRelationship x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "relationship"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the telemetry variant of hydra.ext.azure.dtld.InterfaceContents +interfaceContentsTelemetry :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.InterfaceContents +interfaceContentsTelemetry x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "telemetry"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the context field of hydra.ext.azure.dtld.Interface +interfaceContext :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri +interfaceContext x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Interface +interfaceDescription :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) +interfaceDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Interface +interfaceDisplayName :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) +interfaceDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the extends field of hydra.ext.azure.dtld.Interface +interfaceExtends :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface)) +interfaceExtends x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Interface +interfaceId :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Dtmi +interfaceId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Interface +interfaceInterface :: Typed.TypedName Dtld.Interface +interfaceInterface = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Interface") + +-- | DSL accessor for the schemas field of hydra.ext.azure.dtld.Interface +interfaceSchemas :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface)) +interfaceSchemas x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Interface +interfaceType :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri +interfaceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Interface +interfaceWithComment :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface +interfaceWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the contents field of hydra.ext.azure.dtld.Interface +interfaceWithContents :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents)) -> Typed.TypedTerm Dtld.Interface +interfaceWithContents original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the context field of hydra.ext.azure.dtld.Interface +interfaceWithContext :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Interface +interfaceWithContext original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Interface +interfaceWithDescription :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface +interfaceWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Interface +interfaceWithDisplayName :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface +interfaceWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the extends field of hydra.ext.azure.dtld.Interface +interfaceWithExtends :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface)) -> Typed.TypedTerm Dtld.Interface +interfaceWithExtends original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Interface +interfaceWithId :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.Interface +interfaceWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schemas field of hydra.ext.azure.dtld.Interface +interfaceWithSchemas :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface)) -> Typed.TypedTerm Dtld.Interface +interfaceWithSchemas original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Interface +interfaceWithType :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Interface +interfaceWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "contents")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extends"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "extends")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.azure.dtld.Iri wrapper +iri :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Iri +iri x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Iri"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Iri +iriIri :: Typed.TypedName Dtld.Iri +iriIri = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Iri") + +-- | DSL constructor for hydra.ext.azure.dtld.MapKey +mapKey :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey +mapKey name schema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.MapKey +mapKeyComment :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) +mapKeyComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.MapKey +mapKeyDescription :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) +mapKeyDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.MapKey +mapKeyDisplayName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) +mapKeyDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.MapKey +mapKeyId :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe Dtld.Dtmi) +mapKeyId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.MapKey +mapKeyMapKey :: Typed.TypedName Dtld.MapKey +mapKeyMapKey = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.MapKey") + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.MapKey +mapKeyName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm String +mapKeyName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.MapKey +mapKeySchema :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.Schema +mapKeySchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.MapKey +mapKeyWithComment :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey +mapKeyWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.MapKey +mapKeyWithDescription :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey +mapKeyWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.MapKey +mapKeyWithDisplayName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey +mapKeyWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.MapKey +mapKeyWithId :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.MapKey +mapKeyWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.MapKey +mapKeyWithName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.MapKey +mapKeyWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.MapKey +mapKeyWithSchema :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.MapKey +mapKeyWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.MapValue +mapValue :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue +mapValue name schema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.MapValue +mapValueComment :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) +mapValueComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.MapValue +mapValueDescription :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) +mapValueDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.MapValue +mapValueDisplayName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) +mapValueDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.MapValue +mapValueId :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) +mapValueId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.MapValue +mapValueMapValue :: Typed.TypedName Dtld.MapValue +mapValueMapValue = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.MapValue") + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.MapValue +mapValueName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm String +mapValueName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.MapValue +mapValueSchema :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm Dtld.Schema +mapValueSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.MapValue +mapValueWithComment :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue +mapValueWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.MapValue +mapValueWithDescription :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue +mapValueWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.MapValue +mapValueWithDisplayName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue +mapValueWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.MapValue +mapValueWithId :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.MapValue +mapValueWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.MapValue +mapValueWithName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.MapValue +mapValueWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.MapValue +mapValueWithSchema :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.MapValue +mapValueWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.Property +property :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Property +property type_ name schema id comment description displayName unit writable = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm unit)}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Typed.unTypedTerm writable)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Property +propertyComment :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) +propertyComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Property +propertyDescription :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) +propertyDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Property +propertyDisplayName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) +propertyDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Property +propertyId :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Dtmi) +propertyId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Property +propertyName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm String +propertyName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Property +propertyProperty :: Typed.TypedName Dtld.Property +propertyProperty = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Property") + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.Property +propertySchema :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Schema +propertySchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Property +propertyType :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Iri +propertyType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the unit field of hydra.ext.azure.dtld.Property +propertyUnit :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Unit) +propertyUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Property +propertyWithComment :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property +propertyWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Property +propertyWithDescription :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property +propertyWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Property +propertyWithDisplayName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property +propertyWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Property +propertyWithId :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Property +propertyWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Property +propertyWithName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Property +propertyWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.Property +propertyWithSchema :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Property +propertyWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Property +propertyWithType :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Property +propertyWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unit field of hydra.ext.azure.dtld.Property +propertyWithUnit :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Property +propertyWithUnit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the writable field of hydra.ext.azure.dtld.Property +propertyWithWritable :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Property +propertyWithWritable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the writable field of hydra.ext.azure.dtld.Property +propertyWritable :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Bool) +propertyWritable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.azure.dtld.Relationship +relationship :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe (S.Set Dtld.Property)) -> Typed.TypedTerm (Maybe Dtld.Interface) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Relationship +relationship type_ name id comment description displayName maxMultiplicity minMultiplicity properties target writable = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Typed.unTypedTerm maxMultiplicity)}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Typed.unTypedTerm minMultiplicity)}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Typed.unTypedTerm properties)}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Typed.unTypedTerm writable)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Relationship +relationshipComment :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) +relationshipComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Relationship +relationshipDescription :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) +relationshipDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Relationship +relationshipDisplayName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) +relationshipDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Relationship +relationshipId :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Dtmi) +relationshipId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the maxMultiplicity field of hydra.ext.azure.dtld.Relationship +relationshipMaxMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) +relationshipMaxMultiplicity x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the minMultiplicity field of hydra.ext.azure.dtld.Relationship +relationshipMinMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) +relationshipMinMultiplicity x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Relationship +relationshipName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm String +relationshipName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the properties field of hydra.ext.azure.dtld.Relationship +relationshipProperties :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe (S.Set Dtld.Property)) +relationshipProperties x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Relationship +relationshipRelationship :: Typed.TypedName Dtld.Relationship +relationshipRelationship = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Relationship") + +-- | DSL accessor for the target field of hydra.ext.azure.dtld.Relationship +relationshipTarget :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Interface) +relationshipTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Relationship +relationshipType :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.Iri +relationshipType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Relationship +relationshipWithComment :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship +relationshipWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Relationship +relationshipWithDescription :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship +relationshipWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Relationship +relationshipWithDisplayName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship +relationshipWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Relationship +relationshipWithId :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Relationship +relationshipWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the maxMultiplicity field of hydra.ext.azure.dtld.Relationship +relationshipWithMaxMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Dtld.Relationship +relationshipWithMaxMultiplicity original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the minMultiplicity field of hydra.ext.azure.dtld.Relationship +relationshipWithMinMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Dtld.Relationship +relationshipWithMinMultiplicity original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Relationship +relationshipWithName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Relationship +relationshipWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the properties field of hydra.ext.azure.dtld.Relationship +relationshipWithProperties :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe (S.Set Dtld.Property)) -> Typed.TypedTerm Dtld.Relationship +relationshipWithProperties original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the target field of hydra.ext.azure.dtld.Relationship +relationshipWithTarget :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Interface) -> Typed.TypedTerm Dtld.Relationship +relationshipWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Relationship +relationshipWithType :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Relationship +relationshipWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the writable field of hydra.ext.azure.dtld.Relationship +relationshipWithWritable :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Relationship +relationshipWithWritable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "maxMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minMultiplicity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "minMultiplicity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "writable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the writable field of hydra.ext.azure.dtld.Relationship +relationshipWritable :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Bool) +relationshipWritable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"), + Model.projectionFieldName = (Model.Name "writable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.azure.dtld.SchemaArray +schemaArray :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray +schemaArray type_ elementSchema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Typed.unTypedTerm elementSchema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaArray +schemaArrayComment :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) +schemaArrayComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaArray +schemaArrayDescription :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) +schemaArrayDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaArray +schemaArrayDisplayName :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) +schemaArrayDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elementSchema field of hydra.ext.azure.dtld.SchemaArray +schemaArrayElementSchema :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Schema +schemaArrayElementSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaArray +schemaArrayId :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe Dtld.Dtmi) +schemaArrayId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaArray +schemaArraySchemaArray :: Typed.TypedName Dtld.SchemaArray +schemaArraySchemaArray = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaArray") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaArray +schemaArrayType :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Iri +schemaArrayType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithComment :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithDescription :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithDisplayName :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the elementSchema field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithElementSchema :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithElementSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithId :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaArray +schemaArrayWithType :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaArray +schemaArrayWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elementSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "elementSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the complex variant of hydra.ext.azure.dtld.Schema +schemaComplex :: Typed.TypedTerm Dtld.SchemaComplex -> Typed.TypedTerm Dtld.Schema +schemaComplex x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "complex"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the array variant of hydra.ext.azure.dtld.SchemaComplex +schemaComplexArray :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.SchemaComplex +schemaComplexArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.azure.dtld.SchemaComplex +schemaComplexEnum :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.SchemaComplex +schemaComplexEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.azure.dtld.SchemaComplex +schemaComplexMap :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.SchemaComplex +schemaComplexMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.azure.dtld.SchemaComplex +schemaComplexObject :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.SchemaComplex +schemaComplexObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaComplex +schemaComplexSchemaComplex :: Typed.TypedName Dtld.SchemaComplex +schemaComplexSchemaComplex = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaComplex") + +-- | DSL constructor for hydra.ext.azure.dtld.SchemaEnum +schemaEnum :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm [Dtld.EnumValue] -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnum type_ enumValues valueSchema id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Typed.unTypedTerm enumValues)}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Typed.unTypedTerm valueSchema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumComment :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) +schemaEnumComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumDescription :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) +schemaEnumDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumDisplayName :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) +schemaEnumDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the enumValues field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumEnumValues :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm [Dtld.EnumValue] +schemaEnumEnumValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumId :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe Dtld.Dtmi) +schemaEnumId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaEnum +schemaEnumSchemaEnum :: Typed.TypedName Dtld.SchemaEnum +schemaEnumSchemaEnum = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaEnum") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumType :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.Iri +schemaEnumType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valueSchema field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumValueSchema :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.IntegerOrString +schemaEnumValueSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithComment :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithDescription :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithDisplayName :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the enumValues field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithEnumValues :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm [Dtld.EnumValue] -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithEnumValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithId :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithType :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "valueSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the valueSchema field of hydra.ext.azure.dtld.SchemaEnum +schemaEnumWithValueSchema :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm Dtld.SchemaEnum +schemaEnumWithValueSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "enumValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "enumValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.SchemaInterface +schemaInterface :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.SchemaInterfaceType -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterface id type_ comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceComment :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) +schemaInterfaceComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceDescription :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) +schemaInterfaceDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceDisplayName :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) +schemaInterfaceDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceId :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.Dtmi +schemaInterfaceId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceSchemaInterface :: Typed.TypedName Dtld.SchemaInterface +schemaInterfaceSchemaInterface = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaInterface") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceType :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.SchemaInterfaceType +schemaInterfaceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the array variant of hydra.ext.azure.dtld.SchemaInterfaceType +schemaInterfaceTypeArray :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.SchemaInterfaceType +schemaInterfaceTypeArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.azure.dtld.SchemaInterfaceType +schemaInterfaceTypeEnum :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.SchemaInterfaceType +schemaInterfaceTypeEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.azure.dtld.SchemaInterfaceType +schemaInterfaceTypeMap :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.SchemaInterfaceType +schemaInterfaceTypeMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.azure.dtld.SchemaInterfaceType +schemaInterfaceTypeObject :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.SchemaInterfaceType +schemaInterfaceTypeObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaInterfaceType +schemaInterfaceTypeSchemaInterfaceType :: Typed.TypedName Dtld.SchemaInterfaceType +schemaInterfaceTypeSchemaInterfaceType = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType") + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceWithComment :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterfaceWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceWithDescription :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterfaceWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceWithDisplayName :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterfaceWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceWithId :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterfaceWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaInterface +schemaInterfaceWithType :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.SchemaInterfaceType -> Typed.TypedTerm Dtld.SchemaInterface +schemaInterfaceWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.SchemaMap +schemaMap :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap +schemaMap type_ mapKey mapValue id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Typed.unTypedTerm mapKey)}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Typed.unTypedTerm mapValue)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaMap +schemaMapComment :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) +schemaMapComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaMap +schemaMapDescription :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) +schemaMapDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaMap +schemaMapDisplayName :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) +schemaMapDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaMap +schemaMapId :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe Dtld.Dtmi) +schemaMapId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the mapKey field of hydra.ext.azure.dtld.SchemaMap +schemaMapMapKey :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapKey +schemaMapMapKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the mapValue field of hydra.ext.azure.dtld.SchemaMap +schemaMapMapValue :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapValue +schemaMapMapValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaMap +schemaMapSchemaMap :: Typed.TypedName Dtld.SchemaMap +schemaMapSchemaMap = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaMap") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaMap +schemaMapType :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.Iri +schemaMapType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithComment :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithDescription :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithDisplayName :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithId :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the mapKey field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithMapKey :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithMapKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the mapValue field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithMapValue :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithMapValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaMap +schemaMapWithType :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaMap +schemaMapWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mapKey"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapKey")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mapValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "mapValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.azure.dtld.SchemaObject +schemaObject :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm (S.Set Dtld.Field) -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject +schemaObject type_ fields id comment description displayName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaObject +schemaObjectComment :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) +schemaObjectComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaObject +schemaObjectDescription :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) +schemaObjectDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaObject +schemaObjectDisplayName :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) +schemaObjectDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the fields field of hydra.ext.azure.dtld.SchemaObject +schemaObjectFields :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (S.Set Dtld.Field) +schemaObjectFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaObject +schemaObjectId :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe Dtld.Dtmi) +schemaObjectId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaObject +schemaObjectSchemaObject :: Typed.TypedName Dtld.SchemaObject +schemaObjectSchemaObject = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaObject") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaObject +schemaObjectType :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.Iri +schemaObjectType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithComment :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithDescription :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithDisplayName :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the fields field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithFields :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (S.Set Dtld.Field) -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithId :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaObject +schemaObjectWithType :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaObject +schemaObjectWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the primitive variant of hydra.ext.azure.dtld.Schema +schemaPrimitive :: Typed.TypedTerm Dtld.SchemaPrimitive -> Typed.TypedTerm Dtld.Schema +schemaPrimitive x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primitive"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the boolean variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveBoolean :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the date variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveDate :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveDate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "date"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dateTime variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveDateTime :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveDateTime = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dateTime"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveDouble :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the duration variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveDuration :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveDuration = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "duration"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveFloat :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the integer variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveInteger :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveInteger = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the long variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveLong :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveSchemaPrimitive :: Typed.TypedName Dtld.SchemaPrimitive +schemaPrimitiveSchemaPrimitive = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive") + +-- | DSL injection for the string variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveString :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the time variant of hydra.ext.azure.dtld.SchemaPrimitive +schemaPrimitiveTime :: Typed.TypedTerm Dtld.SchemaPrimitive +schemaPrimitiveTime = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "time"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.azure.dtld.Schema +schemaSchema :: Typed.TypedName Dtld.Schema +schemaSchema = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Schema") + +-- | DSL constructor for hydra.ext.azure.dtld.Telemetry +telemetry :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Telemetry +telemetry type_ name schema id comment description displayName unit = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm comment)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm displayName)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm unit)}]})) + +-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Telemetry +telemetryComment :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) +telemetryComment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.ext.azure.dtld.Telemetry +telemetryDescription :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) +telemetryDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Telemetry +telemetryDisplayName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) +telemetryDisplayName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.azure.dtld.Telemetry +telemetryId :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Dtmi) +telemetryId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.azure.dtld.Telemetry +telemetryName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm String +telemetryName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.azure.dtld.Telemetry +telemetrySchema :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Schema +telemetrySchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Telemetry +telemetryTelemetry :: Typed.TypedName Dtld.Telemetry +telemetryTelemetry = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Telemetry") + +-- | DSL accessor for the type field of hydra.ext.azure.dtld.Telemetry +telemetryType :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Iri +telemetryType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the unit field of hydra.ext.azure.dtld.Telemetry +telemetryUnit :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Unit) +telemetryUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the comment field of hydra.ext.azure.dtld.Telemetry +telemetryWithComment :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry +telemetryWithComment original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.ext.azure.dtld.Telemetry +telemetryWithDescription :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry +telemetryWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Telemetry +telemetryWithDisplayName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry +telemetryWithDisplayName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.azure.dtld.Telemetry +telemetryWithId :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Telemetry +telemetryWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.azure.dtld.Telemetry +telemetryWithName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Telemetry +telemetryWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.azure.dtld.Telemetry +telemetryWithSchema :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Telemetry +telemetryWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.azure.dtld.Telemetry +telemetryWithType :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Telemetry +telemetryWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unit field of hydra.ext.azure.dtld.Telemetry +telemetryWithUnit :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Telemetry +telemetryWithUnit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "comment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "comment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "displayName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"), + Model.projectionFieldName = (Model.Name "displayName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the body of hydra.ext.azure.dtld.Dtmi +unDtmi :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm String +unDtmi x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Dtmi")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.azure.dtld.Iri +unIri :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String +unIri x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Iri")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.azure.dtld.Unit +unUnit :: Typed.TypedTerm Dtld.Unit -> Typed.TypedTerm () +unUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Unit")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.azure.dtld.Unit wrapper +unit :: Typed.TypedTerm () -> Typed.TypedTerm Dtld.Unit +unit x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Unit"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.azure.dtld.Unit +unitUnit :: Typed.TypedName Dtld.Unit +unitUnit = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Unit") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Cpp/Environment.hs b/src/main/haskell/Hydra/Ext/Dsl/Cpp/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Cpp/Environment.hs @@ -0,0 +1,84 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.cpp.environment + +module Hydra.Ext.Dsl.Cpp.Environment where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Util as Util +import qualified Hydra.Ext.Cpp.Environment as Environment +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.ext.cpp.environment.CppEnvironment +cppEnvironment :: Typed.TypedTerm (Util.ModuleNames String) -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name String)) -> Typed.TypedTerm Environment.CppEnvironment +cppEnvironment namespaces boundTypeVariables = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaces"), + Model.fieldTerm = (Typed.unTypedTerm namespaces)}, + Model.Field { + Model.fieldName = (Model.Name "boundTypeVariables"), + Model.fieldTerm = (Typed.unTypedTerm boundTypeVariables)}]})) + +-- | DSL accessor for the boundTypeVariables field of hydra.ext.cpp.environment.CppEnvironment +cppEnvironmentBoundTypeVariables :: Typed.TypedTerm Environment.CppEnvironment -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name String)) +cppEnvironmentBoundTypeVariables x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.projectionFieldName = (Model.Name "boundTypeVariables")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.environment.CppEnvironment +cppEnvironmentCppEnvironment :: Typed.TypedName Environment.CppEnvironment +cppEnvironmentCppEnvironment = Typed.TypedName (Model.Name "hydra.ext.cpp.environment.CppEnvironment") + +-- | DSL accessor for the namespaces field of hydra.ext.cpp.environment.CppEnvironment +cppEnvironmentNamespaces :: Typed.TypedTerm Environment.CppEnvironment -> Typed.TypedTerm (Util.ModuleNames String) +cppEnvironmentNamespaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.projectionFieldName = (Model.Name "namespaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the boundTypeVariables field of hydra.ext.cpp.environment.CppEnvironment +cppEnvironmentWithBoundTypeVariables :: Typed.TypedTerm Environment.CppEnvironment -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name String)) -> Typed.TypedTerm Environment.CppEnvironment +cppEnvironmentWithBoundTypeVariables original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.projectionFieldName = (Model.Name "namespaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "boundTypeVariables"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the namespaces field of hydra.ext.cpp.environment.CppEnvironment +cppEnvironmentWithNamespaces :: Typed.TypedTerm Environment.CppEnvironment -> Typed.TypedTerm (Util.ModuleNames String) -> Typed.TypedTerm Environment.CppEnvironment +cppEnvironmentWithNamespaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "boundTypeVariables"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.environment.CppEnvironment"), + Model.projectionFieldName = (Model.Name "boundTypeVariables")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Cpp/Syntax.hs b/src/main/haskell/Hydra/Ext/Dsl/Cpp/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Cpp/Syntax.hs @@ -0,0 +1,8910 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.cpp.syntax + +module Hydra.Ext.Dsl.Cpp.Syntax where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Cpp.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL name token for hydra.ext.cpp.syntax.AccessSpecifier +accessSpecifierAccessSpecifier :: Typed.TypedName Syntax.AccessSpecifier +accessSpecifierAccessSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier") + +-- | DSL injection for the none variant of hydra.ext.cpp.syntax.AccessSpecifier +accessSpecifierNone :: Typed.TypedTerm Syntax.AccessSpecifier +accessSpecifierNone = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "none"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.cpp.syntax.AccessSpecifier +accessSpecifierPrivate :: Typed.TypedTerm Syntax.AccessSpecifier +accessSpecifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.cpp.syntax.AccessSpecifier +accessSpecifierProtected :: Typed.TypedTerm Syntax.AccessSpecifier +accessSpecifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.cpp.syntax.AccessSpecifier +accessSpecifierPublic :: Typed.TypedTerm Syntax.AccessSpecifier +accessSpecifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.AddOperation +addOperation :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AddOperation +addOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.AddOperation +addOperationAddOperation :: Typed.TypedName Syntax.AddOperation +addOperationAddOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AddOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.AddOperation +addOperationLeft :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.AdditiveExpression +addOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.AddOperation +addOperationRight :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +addOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.AddOperation +addOperationWithLeft :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.AddOperation +addOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.AddOperation +addOperationWithRight :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AddOperation +addOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the add variant of hydra.ext.cpp.syntax.AdditiveExpression +additiveExpressionAdd :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.AdditiveExpression +additiveExpressionAdd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "add"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.AdditiveExpression +additiveExpressionAdditiveExpression :: Typed.TypedName Syntax.AdditiveExpression +additiveExpressionAdditiveExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression") + +-- | DSL injection for the multiplicative variant of hydra.ext.cpp.syntax.AdditiveExpression +additiveExpressionMultiplicative :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression +additiveExpressionMultiplicative x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiplicative"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the subtract variant of hydra.ext.cpp.syntax.AdditiveExpression +additiveExpressionSubtract :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.AdditiveExpression +additiveExpressionSubtract x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subtract"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.AndExpression +andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression +andExpressionAndExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AndExpression") + +-- | DSL injection for the bitwiseAnd variant of hydra.ext.cpp.syntax.AndExpression +andExpressionBitwiseAnd :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.AndExpression +andExpressionBitwiseAnd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseAnd"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the equality variant of hydra.ext.cpp.syntax.AndExpression +andExpressionEquality :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.AndExpression +andExpressionEquality x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equality"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the assignment variant of hydra.ext.cpp.syntax.AssignmentExpression +assignmentExpressionAssignment :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentExpression +assignmentExpressionAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.AssignmentExpression +assignmentExpressionAssignmentExpression :: Typed.TypedName Syntax.AssignmentExpression +assignmentExpressionAssignmentExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression") + +-- | DSL injection for the conditional variant of hydra.ext.cpp.syntax.AssignmentExpression +assignmentExpressionConditional :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.AssignmentExpression +assignmentExpressionConditional x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "conditional"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the assign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorAssignmentOperator :: Typed.TypedName Syntax.AssignmentOperator +assignmentOperatorAssignmentOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator") + +-- | DSL injection for the bitwiseAndAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorBitwiseAndAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorBitwiseAndAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseAndAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bitwiseOrAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorBitwiseOrAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorBitwiseOrAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseOrAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bitwiseXorAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorBitwiseXorAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorBitwiseXorAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseXorAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the divideAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorDivideAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorDivideAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divideAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftShiftAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorLeftShiftAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorLeftShiftAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftShiftAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minusAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorMinusAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorMinusAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minusAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the moduloAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorModuloAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorModuloAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "moduloAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the multiplyAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorMultiplyAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorMultiplyAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiplyAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plusAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorPlusAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorPlusAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plusAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightShiftAssign variant of hydra.ext.cpp.syntax.AssignmentOperator +assignmentOperatorRightShiftAssign :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorRightShiftAssign = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightShiftAssign"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifier :: Typed.TypedTerm Syntax.AccessSpecifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.BaseSpecifier +baseSpecifier access name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "access"), + Model.fieldTerm = (Typed.unTypedTerm access)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the access field of hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifierAccess :: Typed.TypedTerm Syntax.BaseSpecifier -> Typed.TypedTerm Syntax.AccessSpecifier +baseSpecifierAccess x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.projectionFieldName = (Model.Name "access")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifierBaseSpecifier :: Typed.TypedName Syntax.BaseSpecifier +baseSpecifierBaseSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifierName :: Typed.TypedTerm Syntax.BaseSpecifier -> Typed.TypedTerm String +baseSpecifierName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the access field of hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifierWithAccess :: Typed.TypedTerm Syntax.BaseSpecifier -> Typed.TypedTerm Syntax.AccessSpecifier -> Typed.TypedTerm Syntax.BaseSpecifier +baseSpecifierWithAccess original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "access"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.BaseSpecifier +baseSpecifierWithName :: Typed.TypedTerm Syntax.BaseSpecifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.BaseSpecifier +baseSpecifierWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "access"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"), + Model.projectionFieldName = (Model.Name "access")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the auto variant of hydra.ext.cpp.syntax.BasicType +basicTypeAuto :: Typed.TypedTerm Syntax.BasicType +basicTypeAuto = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "auto"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.BasicType +basicTypeBasicType :: Typed.TypedName Syntax.BasicType +basicTypeBasicType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BasicType") + +-- | DSL injection for the bool variant of hydra.ext.cpp.syntax.BasicType +basicTypeBool :: Typed.TypedTerm Syntax.BasicType +basicTypeBool = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bool"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the char variant of hydra.ext.cpp.syntax.BasicType +basicTypeChar :: Typed.TypedTerm Syntax.BasicType +basicTypeChar = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "char"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.cpp.syntax.BasicType +basicTypeDouble :: Typed.TypedTerm Syntax.BasicType +basicTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.cpp.syntax.BasicType +basicTypeFloat :: Typed.TypedTerm Syntax.BasicType +basicTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int variant of hydra.ext.cpp.syntax.BasicType +basicTypeInt :: Typed.TypedTerm Syntax.BasicType +basicTypeInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the named variant of hydra.ext.cpp.syntax.BasicType +basicTypeNamed :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.BasicType +basicTypeNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.cpp.syntax.BasicType +basicTypeString :: Typed.TypedTerm Syntax.BasicType +basicTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the void variant of hydra.ext.cpp.syntax.BasicType +basicTypeVoid :: Typed.TypedTerm Syntax.BasicType +basicTypeVoid = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "void"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorBinaryOperator :: Typed.TypedName Syntax.BinaryOperator +binaryOperatorBinaryOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BinaryOperator") + +-- | DSL injection for the bitwiseAnd variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorBitwiseAnd :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorBitwiseAnd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseAnd"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bitwiseOr variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorBitwiseOr :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorBitwiseOr = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseOr"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bitwiseXor variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorBitwiseXor :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorBitwiseXor = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseXor"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the divide variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorDivide :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorDivide = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divide"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the equal variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorEqual :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greater variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorGreater :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorGreater = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greater"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greaterEqual variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorGreaterEqual :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorGreaterEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftShift variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorLeftShift :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorLeftShift = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftShift"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the less variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorLess :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorLess = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "less"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessEqual variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorLessEqual :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorLessEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorLogicalAnd :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorLogicalAnd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalAnd"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorLogicalOr :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorLogicalOr = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalOr"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minus variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorMinus :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorMinus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the modulo variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorModulo :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorModulo = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modulo"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the multiply variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorMultiply :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorMultiply = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiply"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the notEqual variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorNotEqual :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorNotEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "notEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plus variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorPlus :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorPlus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightShift variant of hydra.ext.cpp.syntax.BinaryOperator +binaryOperatorRightShift :: Typed.TypedTerm Syntax.BinaryOperator +binaryOperatorRightShift = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightShift"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperation :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BitwiseAndOperation +bitwiseAndOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperationBitwiseAndOperation :: Typed.TypedName Syntax.BitwiseAndOperation +bitwiseAndOperationBitwiseAndOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperationLeft :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.AndExpression +bitwiseAndOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperationRight :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.EqualityExpression +bitwiseAndOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperationWithLeft :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BitwiseAndOperation +bitwiseAndOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.BitwiseAndOperation +bitwiseAndOperationWithRight :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BitwiseAndOperation +bitwiseAndOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperation :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BitwiseOrOperation +bitwiseOrOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperationBitwiseOrOperation :: Typed.TypedName Syntax.BitwiseOrOperation +bitwiseOrOperationBitwiseOrOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperationLeft :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression +bitwiseOrOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperationRight :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression +bitwiseOrOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperationWithLeft :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BitwiseOrOperation +bitwiseOrOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.BitwiseOrOperation +bitwiseOrOperationWithRight :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BitwiseOrOperation +bitwiseOrOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperation :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BitwiseXorOperation +bitwiseXorOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperationBitwiseXorOperation :: Typed.TypedName Syntax.BitwiseXorOperation +bitwiseXorOperationBitwiseXorOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperationLeft :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression +bitwiseXorOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperationRight :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.AndExpression +bitwiseXorOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperationWithLeft :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BitwiseXorOperation +bitwiseXorOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.BitwiseXorOperation +bitwiseXorOperationWithRight :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BitwiseXorOperation +bitwiseXorOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.cpp.syntax.BooleanLiteral wrapper +booleanLiteral :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.BooleanLiteral +booleanLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.BooleanLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.BooleanLiteral +booleanLiteralBooleanLiteral :: Typed.TypedName Syntax.BooleanLiteral +booleanLiteralBooleanLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BooleanLiteral") + +-- | DSL constructor for hydra.ext.cpp.syntax.Capture +capture :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Capture +capture name byReference = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "byReference"), + Model.fieldTerm = (Typed.unTypedTerm byReference)}]})) + +-- | DSL accessor for the byReference field of hydra.ext.cpp.syntax.Capture +captureByReference :: Typed.TypedTerm Syntax.Capture -> Typed.TypedTerm Bool +captureByReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.projectionFieldName = (Model.Name "byReference")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Capture +captureCapture :: Typed.TypedName Syntax.Capture +captureCapture = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Capture") + +-- | DSL injection for the captureByValue variant of hydra.ext.cpp.syntax.CaptureList +captureListCaptureByValue :: Typed.TypedTerm Syntax.CaptureList +captureListCaptureByValue = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaptureList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "captureByValue"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.CaptureList +captureListCaptureList :: Typed.TypedName Syntax.CaptureList +captureListCaptureList = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaptureList") + +-- | DSL injection for the captures variant of hydra.ext.cpp.syntax.CaptureList +captureListCaptures :: Typed.TypedTerm [Syntax.Capture] -> Typed.TypedTerm Syntax.CaptureList +captureListCaptures x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaptureList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.Capture +captureName :: Typed.TypedTerm Syntax.Capture -> Typed.TypedTerm String +captureName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the byReference field of hydra.ext.cpp.syntax.Capture +captureWithByReference :: Typed.TypedTerm Syntax.Capture -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Capture +captureWithByReference original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "byReference"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.Capture +captureWithName :: Typed.TypedTerm Syntax.Capture -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Capture +captureWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "byReference"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"), + Model.projectionFieldName = (Model.Name "byReference")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the case variant of hydra.ext.cpp.syntax.CaseStatement +caseStatementCase :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.CaseStatement +caseStatementCase x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "case"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.CaseStatement +caseStatementCaseStatement :: Typed.TypedName Syntax.CaseStatement +caseStatementCaseStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaseStatement") + +-- | DSL injection for the default variant of hydra.ext.cpp.syntax.CaseStatement +caseStatementDefault :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.CaseStatement +caseStatementDefault x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.CaseValue +caseValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.CaseValue +caseValue value statement = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm statement)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.CaseValue +caseValueCaseValue :: Typed.TypedName Syntax.CaseValue +caseValueCaseValue = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaseValue") + +-- | DSL accessor for the statement field of hydra.ext.cpp.syntax.CaseValue +caseValueStatement :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.Statement +caseValueStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the value field of hydra.ext.cpp.syntax.CaseValue +caseValueValue :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.Expression +caseValueValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the statement field of hydra.ext.cpp.syntax.CaseValue +caseValueWithStatement :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.CaseValue +caseValueWithStatement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the value field of hydra.ext.cpp.syntax.CaseValue +caseValueWithValue :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseValue +caseValueWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.cpp.syntax.CharacterLiteral wrapper +characterLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.CharacterLiteral +characterLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.CharacterLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.CharacterLiteral +characterLiteralCharacterLiteral :: Typed.TypedName Syntax.CharacterLiteral +characterLiteralCharacterLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CharacterLiteral") + +-- | DSL constructor for the hydra.ext.cpp.syntax.ClassBody wrapper +classBody :: Typed.TypedTerm [Syntax.MemberSpecification] -> Typed.TypedTerm Syntax.ClassBody +classBody x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassBody"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ClassBody +classBodyClassBody :: Typed.TypedName Syntax.ClassBody +classBodyClassBody = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassBody") + +-- | DSL constructor for hydra.ext.cpp.syntax.ClassDeclaration +classDeclaration :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclaration specifier body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Typed.unTypedTerm specifier)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.ClassDeclaration +classDeclarationBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBody) +classDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ClassDeclaration +classDeclarationClassDeclaration :: Typed.TypedName Syntax.ClassDeclaration +classDeclarationClassDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration") + +-- | DSL accessor for the specifier field of hydra.ext.cpp.syntax.ClassDeclaration +classDeclarationSpecifier :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassSpecifier +classDeclarationSpecifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "specifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.ClassDeclaration +classDeclarationWithBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "specifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the specifier field of hydra.ext.cpp.syntax.ClassDeclaration +classDeclarationWithSpecifier :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithSpecifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the class variant of hydra.ext.cpp.syntax.ClassKey +classKeyClass :: Typed.TypedTerm Syntax.ClassKey +classKeyClass = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.ClassKey +classKeyClassKey :: Typed.TypedName Syntax.ClassKey +classKeyClassKey = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassKey") + +-- | DSL injection for the enum variant of hydra.ext.cpp.syntax.ClassKey +classKeyEnum :: Typed.TypedTerm Syntax.ClassKey +classKeyEnum = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the enumClass variant of hydra.ext.cpp.syntax.ClassKey +classKeyEnumClass :: Typed.TypedTerm Syntax.ClassKey +classKeyEnumClass = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enumClass"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the struct variant of hydra.ext.cpp.syntax.ClassKey +classKeyStruct :: Typed.TypedTerm Syntax.ClassKey +classKeyStruct = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.ClassSpecifier +classSpecifier :: Typed.TypedTerm Syntax.ClassKey -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.BaseSpecifier] -> Typed.TypedTerm Syntax.ClassSpecifier +classSpecifier key name inheritance = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "inheritance"), + Model.fieldTerm = (Typed.unTypedTerm inheritance)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierClassSpecifier :: Typed.TypedName Syntax.ClassSpecifier +classSpecifierClassSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier") + +-- | DSL accessor for the inheritance field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierInheritance :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm [Syntax.BaseSpecifier] +classSpecifierInheritance x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "inheritance")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the key field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierKey :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm Syntax.ClassKey +classSpecifierKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierName :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm String +classSpecifierName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the inheritance field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierWithInheritance :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm [Syntax.BaseSpecifier] -> Typed.TypedTerm Syntax.ClassSpecifier +classSpecifierWithInheritance original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inheritance"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the key field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierWithKey :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm Syntax.ClassKey -> Typed.TypedTerm Syntax.ClassSpecifier +classSpecifierWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inheritance"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "inheritance")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.ClassSpecifier +classSpecifierWithName :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ClassSpecifier +classSpecifierWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "inheritance"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"), + Model.projectionFieldName = (Model.Name "inheritance")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.CommaExpression +commaExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.CommaExpression +commaExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.CommaExpression +commaExpressionCommaExpression :: Typed.TypedName Syntax.CommaExpression +commaExpressionCommaExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CommaExpression") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.CommaExpression +commaExpressionLeft :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.Expression +commaExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.CommaExpression +commaExpressionRight :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.AssignmentExpression +commaExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.CommaExpression +commaExpressionWithLeft :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CommaExpression +commaExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.CommaExpression +commaExpressionWithRight :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.CommaExpression +commaExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Comment +comment :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Comment +comment text isMultiline = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "text"), + Model.fieldTerm = (Typed.unTypedTerm text)}, + Model.Field { + Model.fieldName = (Model.Name "isMultiline"), + Model.fieldTerm = (Typed.unTypedTerm isMultiline)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.Comment +commentComment :: Typed.TypedName Syntax.Comment +commentComment = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Comment") + +-- | DSL accessor for the isMultiline field of hydra.ext.cpp.syntax.Comment +commentIsMultiline :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Bool +commentIsMultiline x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.projectionFieldName = (Model.Name "isMultiline")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the text field of hydra.ext.cpp.syntax.Comment +commentText :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm String +commentText x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.projectionFieldName = (Model.Name "text")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the isMultiline field of hydra.ext.cpp.syntax.Comment +commentWithIsMultiline :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Comment +commentWithIsMultiline original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "text"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.projectionFieldName = (Model.Name "text")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isMultiline"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the text field of hydra.ext.cpp.syntax.Comment +commentWithText :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Comment +commentWithText original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "text"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isMultiline"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"), + Model.projectionFieldName = (Model.Name "isMultiline")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.cpp.syntax.CompoundStatement wrapper +compoundStatement :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.CompoundStatement +compoundStatement x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.CompoundStatement"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.CompoundStatement +compoundStatementCompoundStatement :: Typed.TypedName Syntax.CompoundStatement +compoundStatementCompoundStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CompoundStatement") + +-- | DSL name token for hydra.ext.cpp.syntax.ConditionalExpression +conditionalExpressionConditionalExpression :: Typed.TypedName Syntax.ConditionalExpression +conditionalExpressionConditionalExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression") + +-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.ConditionalExpression +conditionalExpressionLogicalOr :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.ConditionalExpression +conditionalExpressionLogicalOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalOr"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ternary variant of hydra.ext.cpp.syntax.ConditionalExpression +conditionalExpressionTernary :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.ConditionalExpression +conditionalExpressionTernary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ternary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm [Syntax.MemInitializer] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclaration name parameters initializers body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "initializers"), + Model.fieldTerm = (Typed.unTypedTerm initializers)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody +constructorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationConstructorDeclaration :: Typed.TypedName Syntax.ConstructorDeclaration +constructorDeclarationConstructorDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration") + +-- | DSL accessor for the initializers field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationInitializers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.MemInitializer] +constructorDeclarationInitializers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "initializers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationName :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm String +constructorDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationParameters :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.Parameter] +constructorDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationWithBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "initializers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the initializers field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationWithInitializers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.MemInitializer] -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithInitializers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationWithName :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "initializers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.ConstructorDeclaration +constructorDeclarationWithParameters :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "initializers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.ContainerDeclaration +containerDeclarationContainerDeclaration :: Typed.TypedName Syntax.ContainerDeclaration +containerDeclarationContainerDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration") + +-- | DSL injection for the list variant of hydra.ext.cpp.syntax.ContainerDeclaration +containerDeclarationList :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration +containerDeclarationList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.cpp.syntax.ContainerDeclaration +containerDeclarationMap :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration +containerDeclarationMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the optional variant of hydra.ext.cpp.syntax.ContainerDeclaration +containerDeclarationOptional :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration +containerDeclarationOptional x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the set variant of hydra.ext.cpp.syntax.ContainerDeclaration +containerDeclarationSet :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration +containerDeclarationSet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the class variant of hydra.ext.cpp.syntax.Declaration +declarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.Declaration +declarationDeclaration :: Typed.TypedName Syntax.Declaration +declarationDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Declaration") + +-- | DSL injection for the function variant of hydra.ext.cpp.syntax.Declaration +declarationFunction :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the namespace variant of hydra.ext.cpp.syntax.Declaration +declarationNamespace :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationNamespace x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the preprocessor variant of hydra.ext.cpp.syntax.Declaration +declarationPreprocessor :: Typed.TypedTerm Syntax.PreprocessorDirective -> Typed.TypedTerm Syntax.Declaration +declarationPreprocessor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preprocessor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the template variant of hydra.ext.cpp.syntax.Declaration +declarationTemplate :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationTemplate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "template"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typedef variant of hydra.ext.cpp.syntax.Declaration +declarationTypedef :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationTypedef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typedef"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the variable variant of hydra.ext.cpp.syntax.Declaration +declarationVariable :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.Declaration +declarationVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.DefineDirective +defineDirective :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DefineDirective +defineDirective name parameters replacement = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "replacement"), + Model.fieldTerm = (Typed.unTypedTerm replacement)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.DefineDirective +defineDirectiveDefineDirective :: Typed.TypedName Syntax.DefineDirective +defineDirectiveDefineDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DefineDirective") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveName :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm String +defineDirectiveName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveParameters :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe [String]) +defineDirectiveParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the replacement field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveReplacement :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe String) +defineDirectiveReplacement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "replacement")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveWithName :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.DefineDirective +defineDirectiveWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "replacement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "replacement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveWithParameters :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Syntax.DefineDirective +defineDirectiveWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "replacement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "replacement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the replacement field of hydra.ext.cpp.syntax.DefineDirective +defineDirectiveWithReplacement :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DefineDirective +defineDirectiveWithReplacement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "replacement"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclaration :: Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.DestructorDeclaration +destructorDeclaration prefixSpecifiers name suffixSpecifiers body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm prefixSpecifiers)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm suffixSpecifiers)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationBody :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody +destructorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationDestructorDeclaration :: Typed.TypedName Syntax.DestructorDeclaration +destructorDeclarationDestructorDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationName :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm String +destructorDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the prefixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationPrefixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] +destructorDeclarationPrefixSpecifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the suffixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationSuffixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] +destructorDeclarationSuffixSpecifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationWithBody :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.DestructorDeclaration +destructorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationWithName :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.DestructorDeclaration +destructorDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the prefixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationWithPrefixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.DestructorDeclaration +destructorDeclarationWithPrefixSpecifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the suffixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration +destructorDeclarationWithSuffixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.DestructorDeclaration +destructorDeclarationWithSuffixSpecifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.DivideOperation +divideOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.DivideOperation +divideOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.DivideOperation +divideOperationDivideOperation :: Typed.TypedName Syntax.DivideOperation +divideOperationDivideOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DivideOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.DivideOperation +divideOperationLeft :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +divideOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.DivideOperation +divideOperationRight :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.UnaryExpression +divideOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.DivideOperation +divideOperationWithLeft :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.DivideOperation +divideOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.DivideOperation +divideOperationWithRight :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.DivideOperation +divideOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.DoStatement +doStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DoStatement +doStatement body condition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.DoStatement +doStatementBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Statement +doStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.DoStatement +doStatementCondition :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Expression +doStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.DoStatement +doStatementDoStatement :: Typed.TypedName Syntax.DoStatement +doStatementDoStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DoStatement") + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.DoStatement +doStatementWithBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.DoStatement +doStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.DoStatement +doStatementWithCondition :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DoStatement +doStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.ElifDirective +elifDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ElifDirective +elifDirective condition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ElifDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}]})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.ElifDirective +elifDirectiveCondition :: Typed.TypedTerm Syntax.ElifDirective -> Typed.TypedTerm String +elifDirectiveCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ElifDirective"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ElifDirective +elifDirectiveElifDirective :: Typed.TypedName Syntax.ElifDirective +elifDirectiveElifDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ElifDirective") + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.ElifDirective +elifDirectiveWithCondition :: Typed.TypedTerm Syntax.ElifDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ElifDirective +elifDirectiveWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ElifDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.EqualOperation +equalOperation :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualOperation +equalOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.EqualOperation +equalOperationEqualOperation :: Typed.TypedName Syntax.EqualOperation +equalOperationEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.EqualOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.EqualOperation +equalOperationLeft :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.EqualityExpression +equalOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.EqualOperation +equalOperationRight :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +equalOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.EqualOperation +equalOperationWithLeft :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.EqualOperation +equalOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.EqualOperation +equalOperationWithRight :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualOperation +equalOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the equal variant of hydra.ext.cpp.syntax.EqualityExpression +equalityExpressionEqual :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.EqualityExpression +equalityExpressionEqual x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.EqualityExpression +equalityExpressionEqualityExpression :: Typed.TypedName Syntax.EqualityExpression +equalityExpressionEqualityExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.EqualityExpression") + +-- | DSL injection for the notEqual variant of hydra.ext.cpp.syntax.EqualityExpression +equalityExpressionNotEqual :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.EqualityExpression +equalityExpressionNotEqual x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "notEqual"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the relational variant of hydra.ext.cpp.syntax.EqualityExpression +equalityExpressionRelational :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression +equalityExpressionRelational x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "relational"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.ErrorDirective +errorDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ErrorDirective +errorDirective message = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ErrorDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "message"), + Model.fieldTerm = (Typed.unTypedTerm message)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.ErrorDirective +errorDirectiveErrorDirective :: Typed.TypedName Syntax.ErrorDirective +errorDirectiveErrorDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ErrorDirective") + +-- | DSL accessor for the message field of hydra.ext.cpp.syntax.ErrorDirective +errorDirectiveMessage :: Typed.TypedTerm Syntax.ErrorDirective -> Typed.TypedTerm String +errorDirectiveMessage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ErrorDirective"), + Model.projectionFieldName = (Model.Name "message")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the message field of hydra.ext.cpp.syntax.ErrorDirective +errorDirectiveWithMessage :: Typed.TypedTerm Syntax.ErrorDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ErrorDirective +errorDirectiveWithMessage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ErrorDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "message"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the and variant of hydra.ext.cpp.syntax.ExclusiveOrExpression +exclusiveOrExpressionAnd :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression +exclusiveOrExpressionAnd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "and"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the bitwiseXor variant of hydra.ext.cpp.syntax.ExclusiveOrExpression +exclusiveOrExpressionBitwiseXor :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression +exclusiveOrExpressionBitwiseXor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseXor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.ExclusiveOrExpression +exclusiveOrExpressionExclusiveOrExpression :: Typed.TypedName Syntax.ExclusiveOrExpression +exclusiveOrExpressionExclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression") + +-- | DSL constructor for hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignment :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.ExplicitAssignment +explicitAssignment left op right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "op"), + Model.fieldTerm = (Typed.unTypedTerm op)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentExplicitAssignment :: Typed.TypedName Syntax.ExplicitAssignment +explicitAssignmentExplicitAssignment = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentLeft :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.LogicalOrExpression +explicitAssignmentLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the op field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentOp :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentOperator +explicitAssignmentOp x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "op")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentRight :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentExpression +explicitAssignmentRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentWithLeft :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.ExplicitAssignment +explicitAssignmentWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "op"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "op")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the op field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentWithOp :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.ExplicitAssignment +explicitAssignmentWithOp original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "op"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.ExplicitAssignment +explicitAssignmentWithRight :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.ExplicitAssignment +explicitAssignmentWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "op"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"), + Model.projectionFieldName = (Model.Name "op")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the assignment variant of hydra.ext.cpp.syntax.Expression +expressionAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression +expressionAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the comma variant of hydra.ext.cpp.syntax.Expression +expressionComma :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.Expression +expressionComma x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "comma"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.Expression +expressionExpression :: Typed.TypedName Syntax.Expression +expressionExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Expression") + +-- | DSL constructor for the hydra.ext.cpp.syntax.ExpressionStatement wrapper +expressionStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ExpressionStatement +expressionStatement x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.ExpressionStatement"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ExpressionStatement +expressionStatementExpressionStatement :: Typed.TypedName Syntax.ExpressionStatement +expressionStatementExpressionStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExpressionStatement") + +-- | DSL constructor for the hydra.ext.cpp.syntax.FloatingLiteral wrapper +floatingLiteral :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.FloatingLiteral +floatingLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.FloatingLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.FloatingLiteral +floatingLiteralFloatingLiteral :: Typed.TypedName Syntax.FloatingLiteral +floatingLiteralFloatingLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FloatingLiteral") + +-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.ForInit +forInitDeclaration :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.ForInit +forInitDeclaration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.cpp.syntax.ForInit +forInitEmpty :: Typed.TypedTerm Syntax.ForInit +forInitEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.cpp.syntax.ForInit +forInitExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForInit +forInitExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.ForInit +forInitForInit :: Typed.TypedName Syntax.ForInit +forInitForInit = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ForInit") + +-- | DSL constructor for hydra.ext.cpp.syntax.ForStatement +forStatement :: Typed.TypedTerm Syntax.ForInit -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.ForStatement +forStatement init condition increment body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "init"), + Model.fieldTerm = (Typed.unTypedTerm init)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = (Typed.unTypedTerm increment)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.ForStatement +forStatementBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Statement +forStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.ForStatement +forStatementCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression +forStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ForStatement +forStatementForStatement :: Typed.TypedName Syntax.ForStatement +forStatementForStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ForStatement") + +-- | DSL accessor for the increment field of hydra.ext.cpp.syntax.ForStatement +forStatementIncrement :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression +forStatementIncrement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "increment")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the init field of hydra.ext.cpp.syntax.ForStatement +forStatementInit :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.ForInit +forStatementInit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "init")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.ForStatement +forStatementWithBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.ForStatement +forStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "init"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "init")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "increment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.ForStatement +forStatementWithCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForStatement +forStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "init"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "init")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "increment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the increment field of hydra.ext.cpp.syntax.ForStatement +forStatementWithIncrement :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForStatement +forStatementWithIncrement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "init"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "init")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the init field of hydra.ext.cpp.syntax.ForStatement +forStatementWithInit :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.ForInit -> Typed.TypedTerm Syntax.ForStatement +forStatementWithInit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "init"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "increment")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.FunctionApplication +functionApplication :: Typed.TypedTerm Syntax.FunctionIdentifier -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionApplication +functionApplication function arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm function)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.FunctionApplication +functionApplicationArguments :: Typed.TypedTerm Syntax.FunctionApplication -> Typed.TypedTerm [Syntax.Expression] +functionApplicationArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the function field of hydra.ext.cpp.syntax.FunctionApplication +functionApplicationFunction :: Typed.TypedTerm Syntax.FunctionApplication -> Typed.TypedTerm Syntax.FunctionIdentifier +functionApplicationFunction x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionApplication +functionApplicationFunctionApplication :: Typed.TypedName Syntax.FunctionApplication +functionApplicationFunctionApplication = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionApplication") + +-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.FunctionApplication +functionApplicationWithArguments :: Typed.TypedTerm Syntax.FunctionApplication -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionApplication +functionApplicationWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the function field of hydra.ext.cpp.syntax.FunctionApplication +functionApplicationWithFunction :: Typed.TypedTerm Syntax.FunctionApplication -> Typed.TypedTerm Syntax.FunctionIdentifier -> Typed.TypedTerm Syntax.FunctionApplication +functionApplicationWithFunction original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the compound variant of hydra.ext.cpp.syntax.FunctionBody +functionBodyCompound :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.FunctionBody +functionBodyCompound x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "compound"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.FunctionBody +functionBodyDeclaration :: Typed.TypedTerm Syntax.FunctionBody +functionBodyDeclaration = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the default variant of hydra.ext.cpp.syntax.FunctionBody +functionBodyDefault :: Typed.TypedTerm Syntax.FunctionBody +functionBodyDefault = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionBody +functionBodyFunctionBody :: Typed.TypedName Syntax.FunctionBody +functionBodyFunctionBody = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionBody") + +-- | DSL injection for the pure variant of hydra.ext.cpp.syntax.FunctionBody +functionBodyPure :: Typed.TypedTerm Syntax.FunctionBody +functionBodyPure = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pure"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionCallOperation +functionCallOperation function arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm function)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperationArguments :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm [Syntax.Expression] +functionCallOperationArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the function field of hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperationFunction :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression +functionCallOperationFunction x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperationFunctionCallOperation :: Typed.TypedName Syntax.FunctionCallOperation +functionCallOperationFunctionCallOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation") + +-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperationWithArguments :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionCallOperation +functionCallOperationWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the function field of hydra.ext.cpp.syntax.FunctionCallOperation +functionCallOperationWithFunction :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.FunctionCallOperation +functionCallOperationWithFunction original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclaration :: Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclaration prefixSpecifiers returnType name parameters suffixSpecifiers body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm prefixSpecifiers)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm suffixSpecifiers)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationBody :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.FunctionBody +functionDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationFunctionDeclaration :: Typed.TypedName Syntax.FunctionDeclaration +functionDeclarationFunctionDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationName :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm String +functionDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationParameters :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.Parameter] +functionDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the prefixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationPrefixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] +functionDeclarationPrefixSpecifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationReturnType :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.TypeExpression +functionDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the suffixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationSuffixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] +functionDeclarationSuffixSpecifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithBody :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithName :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithParameters :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the prefixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithPrefixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithPrefixSpecifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithReturnType :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "suffixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the suffixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration +functionDeclarationWithSuffixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionDeclaration +functionDeclarationWithSuffixSpecifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "prefixSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "prefixSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "suffixSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionIdentifier +functionIdentifierFunctionIdentifier :: Typed.TypedName Syntax.FunctionIdentifier +functionIdentifierFunctionIdentifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier") + +-- | DSL injection for the qualified variant of hydra.ext.cpp.syntax.FunctionIdentifier +functionIdentifierQualified :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.FunctionIdentifier +functionIdentifierQualified x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "qualified"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simple variant of hydra.ext.cpp.syntax.FunctionIdentifier +functionIdentifierSimple :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.FunctionIdentifier +functionIdentifierSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the explicit variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix +functionSpecifierPrefixExplicit :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix +functionSpecifierPrefixExplicit = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "explicit"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionSpecifierPrefix +functionSpecifierPrefixFunctionSpecifierPrefix :: Typed.TypedName Syntax.FunctionSpecifierPrefix +functionSpecifierPrefixFunctionSpecifierPrefix = + Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix") + +-- | DSL injection for the inline variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix +functionSpecifierPrefixInline :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix +functionSpecifierPrefixInline = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix +functionSpecifierPrefixStatic :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix +functionSpecifierPrefixStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the virtual variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix +functionSpecifierPrefixVirtual :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix +functionSpecifierPrefixVirtual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "virtual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the const variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix +functionSpecifierSuffixConst :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix +functionSpecifierSuffixConst = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "const"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the final variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix +functionSpecifierSuffixFinal :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix +functionSpecifierSuffixFinal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "final"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionSpecifierSuffix +functionSpecifierSuffixFunctionSpecifierSuffix :: Typed.TypedName Syntax.FunctionSpecifierSuffix +functionSpecifierSuffixFunctionSpecifierSuffix = + Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix") + +-- | DSL injection for the noexcept variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix +functionSpecifierSuffixNoexcept :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix +functionSpecifierSuffixNoexcept = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "noexcept"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the override variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix +functionSpecifierSuffixOverride :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix +functionSpecifierSuffixOverride = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.FunctionType +functionType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.FunctionType +functionType returnType parameters = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.FunctionType +functionTypeFunctionType :: Typed.TypedName Syntax.FunctionType +functionTypeFunctionType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionType") + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.FunctionType +functionTypeParameters :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Parameter] +functionTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.cpp.syntax.FunctionType +functionTypeReturnType :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.TypeExpression +functionTypeReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.FunctionType +functionTypeWithParameters :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.FunctionType +functionTypeWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the returnType field of hydra.ext.cpp.syntax.FunctionType +functionTypeWithReturnType :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.FunctionType +functionTypeWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterEqualOperation +greaterEqualOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperationGreaterEqualOperation :: Typed.TypedName Syntax.GreaterEqualOperation +greaterEqualOperationGreaterEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperationLeft :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +greaterEqualOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperationRight :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.ShiftExpression +greaterEqualOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperationWithLeft :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.GreaterEqualOperation +greaterEqualOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.GreaterEqualOperation +greaterEqualOperationWithRight :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterEqualOperation +greaterEqualOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.GreaterOperation +greaterOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterOperation +greaterOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.GreaterOperation +greaterOperationGreaterOperation :: Typed.TypedName Syntax.GreaterOperation +greaterOperationGreaterOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.GreaterOperation") + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.GreaterOperation +greaterOperationLeft :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.RelationalExpression +greaterOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.GreaterOperation +greaterOperationRight :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.ShiftExpression +greaterOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.GreaterOperation +greaterOperationWithLeft :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.GreaterOperation +greaterOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.GreaterOperation +greaterOperationWithRight :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterOperation +greaterOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.IfDirective +ifDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfDirective +ifDirective condition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}]})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.IfDirective +ifDirectiveCondition :: Typed.TypedTerm Syntax.IfDirective -> Typed.TypedTerm String +ifDirectiveCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IfDirective"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.IfDirective +ifDirectiveIfDirective :: Typed.TypedName Syntax.IfDirective +ifDirectiveIfDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfDirective") + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.IfDirective +ifDirectiveWithCondition :: Typed.TypedTerm Syntax.IfDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfDirective +ifDirectiveWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.IfdefDirective +ifdefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfdefDirective +ifdefDirective identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfdefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.cpp.syntax.IfdefDirective +ifdefDirectiveIdentifier :: Typed.TypedTerm Syntax.IfdefDirective -> Typed.TypedTerm String +ifdefDirectiveIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IfdefDirective"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.IfdefDirective +ifdefDirectiveIfdefDirective :: Typed.TypedName Syntax.IfdefDirective +ifdefDirectiveIfdefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfdefDirective") + +-- | DSL updater for the identifier field of hydra.ext.cpp.syntax.IfdefDirective +ifdefDirectiveWithIdentifier :: Typed.TypedTerm Syntax.IfdefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfdefDirective +ifdefDirectiveWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfdefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.IfndefDirective +ifndefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfndefDirective +ifndefDirective identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfndefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.cpp.syntax.IfndefDirective +ifndefDirectiveIdentifier :: Typed.TypedTerm Syntax.IfndefDirective -> Typed.TypedTerm String +ifndefDirectiveIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IfndefDirective"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.IfndefDirective +ifndefDirectiveIfndefDirective :: Typed.TypedName Syntax.IfndefDirective +ifndefDirectiveIfndefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfndefDirective") + +-- | DSL updater for the identifier field of hydra.ext.cpp.syntax.IfndefDirective +ifndefDirectiveWithIdentifier :: Typed.TypedTerm Syntax.IfndefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfndefDirective +ifndefDirectiveWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfndefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.IncludeDirective +includeDirective :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IncludeDirective +includeDirective name isSystem = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "isSystem"), + Model.fieldTerm = (Typed.unTypedTerm isSystem)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.IncludeDirective +includeDirectiveIncludeDirective :: Typed.TypedName Syntax.IncludeDirective +includeDirectiveIncludeDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IncludeDirective") + +-- | DSL accessor for the isSystem field of hydra.ext.cpp.syntax.IncludeDirective +includeDirectiveIsSystem :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm Bool +includeDirectiveIsSystem x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.projectionFieldName = (Model.Name "isSystem")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.IncludeDirective +includeDirectiveName :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm String +includeDirectiveName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the isSystem field of hydra.ext.cpp.syntax.IncludeDirective +includeDirectiveWithIsSystem :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IncludeDirective +includeDirectiveWithIsSystem original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isSystem"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.IncludeDirective +includeDirectiveWithName :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IncludeDirective +includeDirectiveWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isSystem"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"), + Model.projectionFieldName = (Model.Name "isSystem")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the bitwiseOr variant of hydra.ext.cpp.syntax.InclusiveOrExpression +inclusiveOrExpressionBitwiseOr :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression +inclusiveOrExpressionBitwiseOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseOr"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the exclusiveOr variant of hydra.ext.cpp.syntax.InclusiveOrExpression +inclusiveOrExpressionExclusiveOr :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression +inclusiveOrExpressionExclusiveOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "exclusiveOr"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.InclusiveOrExpression +inclusiveOrExpressionInclusiveOrExpression :: Typed.TypedName Syntax.InclusiveOrExpression +inclusiveOrExpressionInclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression") + +-- | DSL injection for the binary variant of hydra.ext.cpp.syntax.IntegerLiteral +integerLiteralBinary :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the decimal variant of hydra.ext.cpp.syntax.IntegerLiteral +integerLiteralDecimal :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralDecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the hexadecimal variant of hydra.ext.cpp.syntax.IntegerLiteral +integerLiteralHexadecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralHexadecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hexadecimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.IntegerLiteral +integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral +integerLiteralIntegerLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral") + +-- | DSL injection for the octal variant of hydra.ext.cpp.syntax.IntegerLiteral +integerLiteralOctal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralOctal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "octal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the do variant of hydra.ext.cpp.syntax.IterationStatement +iterationStatementDo :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementDo x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "do"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the for variant of hydra.ext.cpp.syntax.IterationStatement +iterationStatementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementFor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "for"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.IterationStatement +iterationStatementIterationStatement :: Typed.TypedName Syntax.IterationStatement +iterationStatementIterationStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IterationStatement") + +-- | DSL injection for the rangeFor variant of hydra.ext.cpp.syntax.IterationStatement +iterationStatementRangeFor :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementRangeFor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rangeFor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the while variant of hydra.ext.cpp.syntax.IterationStatement +iterationStatementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementWhile x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "while"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the break variant of hydra.ext.cpp.syntax.JumpStatement +jumpStatementBreak :: Typed.TypedTerm Syntax.JumpStatement +jumpStatementBreak = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "break"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the continue variant of hydra.ext.cpp.syntax.JumpStatement +jumpStatementContinue :: Typed.TypedTerm Syntax.JumpStatement +jumpStatementContinue = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "continue"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.JumpStatement +jumpStatementJumpStatement :: Typed.TypedName Syntax.JumpStatement +jumpStatementJumpStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.JumpStatement") + +-- | DSL injection for the returnValue variant of hydra.ext.cpp.syntax.JumpStatement +jumpStatementReturnValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JumpStatement +jumpStatementReturnValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "returnValue"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the returnVoid variant of hydra.ext.cpp.syntax.JumpStatement +jumpStatementReturnVoid :: Typed.TypedTerm Syntax.JumpStatement +jumpStatementReturnVoid = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "returnVoid"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the throw variant of hydra.ext.cpp.syntax.JumpStatement +jumpStatementThrow :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JumpStatement +jumpStatementThrow x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "throw"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LabeledStatement +labeledStatement :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatement label statement = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Typed.unTypedTerm label)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm statement)}]})) + +-- | DSL accessor for the label field of hydra.ext.cpp.syntax.LabeledStatement +labeledStatementLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm String +labeledStatementLabel x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "label")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LabeledStatement +labeledStatementLabeledStatement :: Typed.TypedName Syntax.LabeledStatement +labeledStatementLabeledStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LabeledStatement") + +-- | DSL accessor for the statement field of hydra.ext.cpp.syntax.LabeledStatement +labeledStatementStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement +labeledStatementStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the label field of hydra.ext.cpp.syntax.LabeledStatement +labeledStatementWithLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatementWithLabel original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statement field of hydra.ext.cpp.syntax.LabeledStatement +labeledStatementWithStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatementWithStatement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "label")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LambdaExpression +lambdaExpression :: Typed.TypedTerm Syntax.CaptureList -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpression captures parameters returnType body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Typed.unTypedTerm captures)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CompoundStatement +lambdaExpressionBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the captures field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionCaptures :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CaptureList +lambdaExpressionCaptures x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "captures")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression +lambdaExpressionLambdaExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LambdaExpression") + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Parameter] +lambdaExpressionParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionReturnType :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm (Maybe Syntax.TypeExpression) +lambdaExpressionReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionWithBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "captures")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the captures field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionWithCaptures :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CaptureList -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithCaptures original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionWithParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "captures")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.cpp.syntax.LambdaExpression +lambdaExpressionWithReturnType :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "captures"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "captures")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperation :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.LeftShiftOperation +leftShiftOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperationLeft :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression +leftShiftOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperationLeftShiftOperation :: Typed.TypedName Syntax.LeftShiftOperation +leftShiftOperationLeftShiftOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperationRight :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.AdditiveExpression +leftShiftOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperationWithLeft :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LeftShiftOperation +leftShiftOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.LeftShiftOperation +leftShiftOperationWithRight :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.LeftShiftOperation +leftShiftOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessEqualOperation +lessEqualOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperationLeft :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +lessEqualOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperationLessEqualOperation :: Typed.TypedName Syntax.LessEqualOperation +lessEqualOperationLessEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperationRight :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.ShiftExpression +lessEqualOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperationWithLeft :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.LessEqualOperation +lessEqualOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.LessEqualOperation +lessEqualOperationWithRight :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessEqualOperation +lessEqualOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LessOperation +lessOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessOperation +lessOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.LessOperation +lessOperationLeft :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.RelationalExpression +lessOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LessOperation +lessOperationLessOperation :: Typed.TypedName Syntax.LessOperation +lessOperationLessOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LessOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.LessOperation +lessOperationRight :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.ShiftExpression +lessOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.LessOperation +lessOperationWithLeft :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.LessOperation +lessOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.LessOperation +lessOperationWithRight :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessOperation +lessOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.LineDirective +lineDirective :: Typed.TypedTerm Int -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.LineDirective +lineDirective lineNumber filename = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lineNumber"), + Model.fieldTerm = (Typed.unTypedTerm lineNumber)}, + Model.Field { + Model.fieldName = (Model.Name "filename"), + Model.fieldTerm = (Typed.unTypedTerm filename)}]})) + +-- | DSL accessor for the filename field of hydra.ext.cpp.syntax.LineDirective +lineDirectiveFilename :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm (Maybe String) +lineDirectiveFilename x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.projectionFieldName = (Model.Name "filename")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LineDirective +lineDirectiveLineDirective :: Typed.TypedName Syntax.LineDirective +lineDirectiveLineDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LineDirective") + +-- | DSL accessor for the lineNumber field of hydra.ext.cpp.syntax.LineDirective +lineDirectiveLineNumber :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm Int +lineDirectiveLineNumber x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.projectionFieldName = (Model.Name "lineNumber")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the filename field of hydra.ext.cpp.syntax.LineDirective +lineDirectiveWithFilename :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.LineDirective +lineDirectiveWithFilename original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lineNumber"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.projectionFieldName = (Model.Name "lineNumber")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "filename"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the lineNumber field of hydra.ext.cpp.syntax.LineDirective +lineDirectiveWithLineNumber :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm Int -> Typed.TypedTerm Syntax.LineDirective +lineDirectiveWithLineNumber original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lineNumber"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "filename"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"), + Model.projectionFieldName = (Model.Name "filename")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.ListDeclaration +listDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ListDeclaration +listDeclaration elementType name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the elementType field of hydra.ext.cpp.syntax.ListDeclaration +listDeclarationElementType :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm Syntax.TypeExpression +listDeclarationElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ListDeclaration +listDeclarationListDeclaration :: Typed.TypedName Syntax.ListDeclaration +listDeclarationListDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ListDeclaration") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.ListDeclaration +listDeclarationName :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm String +listDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the elementType field of hydra.ext.cpp.syntax.ListDeclaration +listDeclarationWithElementType :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.ListDeclaration +listDeclarationWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.ListDeclaration +listDeclarationWithName :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ListDeclaration +listDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the boolean variant of hydra.ext.cpp.syntax.Literal +literalBoolean :: Typed.TypedTerm Syntax.BooleanLiteral -> Typed.TypedTerm Syntax.Literal +literalBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the character variant of hydra.ext.cpp.syntax.Literal +literalCharacter :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm Syntax.Literal +literalCharacter x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "character"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the floating variant of hydra.ext.cpp.syntax.Literal +literalFloating :: Typed.TypedTerm Syntax.FloatingLiteral -> Typed.TypedTerm Syntax.Literal +literalFloating x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "floating"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the integer variant of hydra.ext.cpp.syntax.Literal +literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal +literalInteger x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.Literal +literalLiteral :: Typed.TypedName Syntax.Literal +literalLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Literal") + +-- | DSL injection for the null variant of hydra.ext.cpp.syntax.Literal +literalNull :: Typed.TypedTerm Syntax.Literal +literalNull = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.cpp.syntax.Literal +literalString :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm Syntax.Literal +literalString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the inclusiveOr variant of hydra.ext.cpp.syntax.LogicalAndExpression +logicalAndExpressionInclusiveOr :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.LogicalAndExpression +logicalAndExpressionInclusiveOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inclusiveOr"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.LogicalAndExpression +logicalAndExpressionLogicalAnd :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.LogicalAndExpression +logicalAndExpressionLogicalAnd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalAnd"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.LogicalAndExpression +logicalAndExpressionLogicalAndExpression :: Typed.TypedName Syntax.LogicalAndExpression +logicalAndExpressionLogicalAndExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression") + +-- | DSL constructor for hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperation :: Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.LogicalAndOperation +logicalAndOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperationLeft :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.LogicalAndExpression +logicalAndOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperationLogicalAndOperation :: Typed.TypedName Syntax.LogicalAndOperation +logicalAndOperationLogicalAndOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperationRight :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression +logicalAndOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperationWithLeft :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalAndOperation +logicalAndOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.LogicalAndOperation +logicalAndOperationWithRight :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.LogicalAndOperation +logicalAndOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.LogicalOrExpression +logicalOrExpressionLogicalAnd :: Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalOrExpression +logicalOrExpressionLogicalAnd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalAnd"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.LogicalOrExpression +logicalOrExpressionLogicalOr :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalOrExpression +logicalOrExpressionLogicalOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalOr"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.LogicalOrExpression +logicalOrExpressionLogicalOrExpression :: Typed.TypedName Syntax.LogicalOrExpression +logicalOrExpressionLogicalOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression") + +-- | DSL constructor for hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperation :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalOrOperation +logicalOrOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperationLeft :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalOrExpression +logicalOrOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperationLogicalOrOperation :: Typed.TypedName Syntax.LogicalOrOperation +logicalOrOperationLogicalOrOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperationRight :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalAndExpression +logicalOrOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperationWithLeft :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.LogicalOrOperation +logicalOrOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.LogicalOrOperation +logicalOrOperationWithRight :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalOrOperation +logicalOrOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Map +map :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.Map +map keyType valueType entries = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm keyType)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm valueType)}, + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Typed.unTypedTerm entries)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.MapDeclaration +mapDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MapDeclaration +mapDeclaration keyType valueType name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm keyType)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm valueType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the keyType field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationKeyType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression +mapDeclarationKeyType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationMapDeclaration :: Typed.TypedName Syntax.MapDeclaration +mapDeclarationMapDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MapDeclaration") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationName :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm String +mapDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valueType field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationValueType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression +mapDeclarationValueType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the keyType field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationWithKeyType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.MapDeclaration +mapDeclarationWithKeyType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationWithName :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MapDeclaration +mapDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.MapDeclaration +mapDeclarationWithValueType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.MapDeclaration +mapDeclarationWithValueType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the entries field of hydra.ext.cpp.syntax.Map +mapEntries :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm [Syntax.MapEntry] +mapEntries x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "entries")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.cpp.syntax.MapEntry +mapEntry :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry +mapEntry key value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the key field of hydra.ext.cpp.syntax.MapEntry +mapEntryKey :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression +mapEntryKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.MapEntry +mapEntryMapEntry :: Typed.TypedName Syntax.MapEntry +mapEntryMapEntry = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MapEntry") + +-- | DSL accessor for the value field of hydra.ext.cpp.syntax.MapEntry +mapEntryValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression +mapEntryValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the key field of hydra.ext.cpp.syntax.MapEntry +mapEntryWithKey :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry +mapEntryWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.cpp.syntax.MapEntry +mapEntryWithValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry +mapEntryWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the keyType field of hydra.ext.cpp.syntax.Map +mapKeyType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression +mapKeyType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Map +mapMap :: Typed.TypedName Syntax.Map +mapMap = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Map") + +-- | DSL accessor for the valueType field of hydra.ext.cpp.syntax.Map +mapValueType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression +mapValueType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the entries field of hydra.ext.cpp.syntax.Map +mapWithEntries :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.Map +mapWithEntries original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the keyType field of hydra.ext.cpp.syntax.Map +mapWithKeyType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Map +mapWithKeyType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "entries")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.Map +mapWithValueType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Map +mapWithValueType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"), + Model.projectionFieldName = (Model.Name "entries")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.MemInitializer +memInitializer :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MemInitializer +memInitializer name arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.MemInitializer +memInitializerArguments :: Typed.TypedTerm Syntax.MemInitializer -> Typed.TypedTerm [Syntax.Expression] +memInitializerArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.MemInitializer +memInitializerMemInitializer :: Typed.TypedName Syntax.MemInitializer +memInitializerMemInitializer = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemInitializer") + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.MemInitializer +memInitializerName :: Typed.TypedTerm Syntax.MemInitializer -> Typed.TypedTerm String +memInitializerName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.MemInitializer +memInitializerWithArguments :: Typed.TypedTerm Syntax.MemInitializer -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MemInitializer +memInitializerWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.MemInitializer +memInitializerWithName :: Typed.TypedTerm Syntax.MemInitializer -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MemInitializer +memInitializerWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MemberAccessOperation +memberAccessOperation object member = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm object)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm member)}]})) + +-- | DSL accessor for the member field of hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperationMember :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm String +memberAccessOperationMember x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperationMemberAccessOperation :: Typed.TypedName Syntax.MemberAccessOperation +memberAccessOperationMemberAccessOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation") + +-- | DSL accessor for the object field of hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperationObject :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression +memberAccessOperationObject x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.projectionFieldName = (Model.Name "object")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the member field of hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperationWithMember :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MemberAccessOperation +memberAccessOperationWithMember original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.projectionFieldName = (Model.Name "object")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the object field of hydra.ext.cpp.syntax.MemberAccessOperation +memberAccessOperationWithObject :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.MemberAccessOperation +memberAccessOperationWithObject original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the constructor variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the destructor variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationDestructor :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationDestructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "destructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the function variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationFunction :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationMemberDeclaration :: Typed.TypedName Syntax.MemberDeclaration +memberDeclarationMemberDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration") + +-- | DSL injection for the nestedClass variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationNestedClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationNestedClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nestedClass"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the template variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationTemplate :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationTemplate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "template"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the variable variant of hydra.ext.cpp.syntax.MemberDeclaration +memberDeclarationVariable :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration +memberDeclarationVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the accessLabel variant of hydra.ext.cpp.syntax.MemberSpecification +memberSpecificationAccessLabel :: Typed.TypedTerm Syntax.AccessSpecifier -> Typed.TypedTerm Syntax.MemberSpecification +memberSpecificationAccessLabel x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberSpecification"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "accessLabel"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the member variant of hydra.ext.cpp.syntax.MemberSpecification +memberSpecificationMember :: Typed.TypedTerm Syntax.MemberDeclaration -> Typed.TypedTerm Syntax.MemberSpecification +memberSpecificationMember x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberSpecification"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.MemberSpecification +memberSpecificationMemberSpecification :: Typed.TypedName Syntax.MemberSpecification +memberSpecificationMemberSpecification = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberSpecification") + +-- | DSL constructor for hydra.ext.cpp.syntax.ModuloOperation +moduloOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.ModuloOperation +moduloOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.ModuloOperation +moduloOperationLeft :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +moduloOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ModuloOperation +moduloOperationModuloOperation :: Typed.TypedName Syntax.ModuloOperation +moduloOperationModuloOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ModuloOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.ModuloOperation +moduloOperationRight :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.UnaryExpression +moduloOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.ModuloOperation +moduloOperationWithLeft :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.ModuloOperation +moduloOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.ModuloOperation +moduloOperationWithRight :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.ModuloOperation +moduloOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the divide variant of hydra.ext.cpp.syntax.MultiplicativeExpression +multiplicativeExpressionDivide :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionDivide x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divide"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the modulo variant of hydra.ext.cpp.syntax.MultiplicativeExpression +multiplicativeExpressionModulo :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionModulo x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modulo"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.MultiplicativeExpression +multiplicativeExpressionMultiplicativeExpression :: Typed.TypedName Syntax.MultiplicativeExpression +multiplicativeExpressionMultiplicativeExpression = + Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression") + +-- | DSL injection for the multiply variant of hydra.ext.cpp.syntax.MultiplicativeExpression +multiplicativeExpressionMultiply :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionMultiply x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiply"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unary variant of hydra.ext.cpp.syntax.MultiplicativeExpression +multiplicativeExpressionUnary :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionUnary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplyOperation +multiplyOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperationLeft :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplyOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperationMultiplyOperation :: Typed.TypedName Syntax.MultiplyOperation +multiplyOperationMultiplyOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperationRight :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.UnaryExpression +multiplyOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperationWithLeft :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplyOperation +multiplyOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.MultiplyOperation +multiplyOperationWithRight :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplyOperation +multiplyOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclaration name declarations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Typed.unTypedTerm declarations)}]})) + +-- | DSL accessor for the declarations field of hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclarationDeclarations :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm [Syntax.Declaration] +namespaceDeclarationDeclarations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "declarations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclarationName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm String +namespaceDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclarationNamespaceDeclaration :: Typed.TypedName Syntax.NamespaceDeclaration +namespaceDeclarationNamespaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration") + +-- | DSL updater for the declarations field of hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclarationWithDeclarations :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclarationWithDeclarations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.NamespaceDeclaration +namespaceDeclarationWithName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "declarations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperation :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.NotEqualOperation +notEqualOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperationLeft :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.EqualityExpression +notEqualOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperationNotEqualOperation :: Typed.TypedName Syntax.NotEqualOperation +notEqualOperationNotEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation") + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperationRight :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +notEqualOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperationWithLeft :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.NotEqualOperation +notEqualOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.NotEqualOperation +notEqualOperationWithRight :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.NotEqualOperation +notEqualOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Optional +optional :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Optional +optional valueType value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm valueType)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.OptionalDeclaration +optionalDeclaration valueType name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm valueType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclarationName :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm String +optionalDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclarationOptionalDeclaration :: Typed.TypedName Syntax.OptionalDeclaration +optionalDeclarationOptionalDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration") + +-- | DSL accessor for the valueType field of hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclarationValueType :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm Syntax.TypeExpression +optionalDeclarationValueType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclarationWithName :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.OptionalDeclaration +optionalDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.OptionalDeclaration +optionalDeclarationWithValueType :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.OptionalDeclaration +optionalDeclarationWithValueType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.Optional +optionalOptional :: Typed.TypedName Syntax.Optional +optionalOptional = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Optional") + +-- | DSL accessor for the value field of hydra.ext.cpp.syntax.Optional +optionalValue :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm (Maybe Syntax.Expression) +optionalValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valueType field of hydra.ext.cpp.syntax.Optional +optionalValueType :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm Syntax.TypeExpression +optionalValueType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the value field of hydra.ext.cpp.syntax.Optional +optionalWithValue :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Optional +optionalWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.Optional +optionalWithValueType :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Optional +optionalWithValueType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.cpp.syntax.OverloadedLambdas wrapper +overloadedLambdas :: Typed.TypedTerm [Syntax.LambdaExpression] -> Typed.TypedTerm Syntax.OverloadedLambdas +overloadedLambdas x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.OverloadedLambdas"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.OverloadedLambdas +overloadedLambdasOverloadedLambdas :: Typed.TypedName Syntax.OverloadedLambdas +overloadedLambdasOverloadedLambdas = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.OverloadedLambdas") + +-- | DSL constructor for hydra.ext.cpp.syntax.Parameter +parameter :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Parameter +parameter type_ name unnamed defaultValue = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "unnamed"), + Model.fieldTerm = (Typed.unTypedTerm unnamed)}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Typed.unTypedTerm defaultValue)}]})) + +-- | DSL accessor for the defaultValue field of hydra.ext.cpp.syntax.Parameter +parameterDefaultValue :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm (Maybe Syntax.Expression) +parameterDefaultValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.Parameter +parameterName :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm String +parameterName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Parameter +parameterParameter :: Typed.TypedName Syntax.Parameter +parameterParameter = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Parameter") + +-- | DSL accessor for the type field of hydra.ext.cpp.syntax.Parameter +parameterType :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Syntax.TypeExpression +parameterType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the unnamed field of hydra.ext.cpp.syntax.Parameter +parameterUnnamed :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Bool +parameterUnnamed x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "unnamed")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the defaultValue field of hydra.ext.cpp.syntax.Parameter +parameterWithDefaultValue :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Parameter +parameterWithDefaultValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unnamed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "unnamed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.Parameter +parameterWithName :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Parameter +parameterWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unnamed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "unnamed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.cpp.syntax.Parameter +parameterWithType :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Parameter +parameterWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unnamed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "unnamed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unnamed field of hydra.ext.cpp.syntax.Parameter +parameterWithUnnamed :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Parameter +parameterWithUnnamed original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unnamed"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"), + Model.projectionFieldName = (Model.Name "defaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.PatternMatch +patternMatch :: Typed.TypedTerm Syntax.Visitor -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PatternMatch +patternMatch visitor variant = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "visitor"), + Model.fieldTerm = (Typed.unTypedTerm visitor)}, + Model.Field { + Model.fieldName = (Model.Name "variant"), + Model.fieldTerm = (Typed.unTypedTerm variant)}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.PatternMatch +patternMatchPatternMatch :: Typed.TypedName Syntax.PatternMatch +patternMatchPatternMatch = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PatternMatch") + +-- | DSL accessor for the variant field of hydra.ext.cpp.syntax.PatternMatch +patternMatchVariant :: Typed.TypedTerm Syntax.PatternMatch -> Typed.TypedTerm Syntax.Expression +patternMatchVariant x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.projectionFieldName = (Model.Name "variant")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the visitor field of hydra.ext.cpp.syntax.PatternMatch +patternMatchVisitor :: Typed.TypedTerm Syntax.PatternMatch -> Typed.TypedTerm Syntax.Visitor +patternMatchVisitor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.projectionFieldName = (Model.Name "visitor")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the variant field of hydra.ext.cpp.syntax.PatternMatch +patternMatchWithVariant :: Typed.TypedTerm Syntax.PatternMatch -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PatternMatch +patternMatchWithVariant original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "visitor"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.projectionFieldName = (Model.Name "visitor")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variant"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the visitor field of hydra.ext.cpp.syntax.PatternMatch +patternMatchWithVisitor :: Typed.TypedTerm Syntax.PatternMatch -> Typed.TypedTerm Syntax.Visitor -> Typed.TypedTerm Syntax.PatternMatch +patternMatchWithVisitor original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "visitor"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "variant"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"), + Model.projectionFieldName = (Model.Name "variant")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.PointerMemberAccessOperation +pointerMemberAccessOperation pointer member = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm pointer)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm member)}]})) + +-- | DSL accessor for the member field of hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperationMember :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm String +pointerMemberAccessOperationMember x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pointer field of hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperationPointer :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression +pointerMemberAccessOperationPointer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperationPointerMemberAccessOperation :: Typed.TypedName Syntax.PointerMemberAccessOperation +pointerMemberAccessOperationPointerMemberAccessOperation = + Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation") + +-- | DSL updater for the member field of hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperationWithMember :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.PointerMemberAccessOperation +pointerMemberAccessOperationWithMember original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the pointer field of hydra.ext.cpp.syntax.PointerMemberAccessOperation +pointerMemberAccessOperationWithPointer :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.PointerMemberAccessOperation +pointerMemberAccessOperationWithPointer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the functionCall variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionFunctionCall :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionFunctionCall x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "functionCall"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the memberAccess variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionMemberAccess :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "memberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pointerMemberAccess variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionPointerMemberAccess :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionPointerMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointerMemberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postDecrement variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionPostDecrement :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionPostDecrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postDecrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postIncrement variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionPostIncrement :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionPostIncrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postIncrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionPostfixExpression :: Typed.TypedName Syntax.PostfixExpression +postfixExpressionPostfixExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PostfixExpression") + +-- | DSL injection for the primary variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionPrimary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the subscript variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionSubscript :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionSubscript x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subscript"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the templateFunctionCall variant of hydra.ext.cpp.syntax.PostfixExpression +postfixExpressionTemplateFunctionCall :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression +postfixExpressionTemplateFunctionCall x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "templateFunctionCall"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.PragmaDirective +pragmaDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PragmaDirective +pragmaDirective content = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PragmaDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "content"), + Model.fieldTerm = (Typed.unTypedTerm content)}]})) + +-- | DSL accessor for the content field of hydra.ext.cpp.syntax.PragmaDirective +pragmaDirectiveContent :: Typed.TypedTerm Syntax.PragmaDirective -> Typed.TypedTerm String +pragmaDirectiveContent x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PragmaDirective"), + Model.projectionFieldName = (Model.Name "content")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.PragmaDirective +pragmaDirectivePragmaDirective :: Typed.TypedName Syntax.PragmaDirective +pragmaDirectivePragmaDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PragmaDirective") + +-- | DSL updater for the content field of hydra.ext.cpp.syntax.PragmaDirective +pragmaDirectiveWithContent :: Typed.TypedTerm Syntax.PragmaDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.PragmaDirective +pragmaDirectiveWithContent original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PragmaDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "content"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the define variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveDefine :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveDefine x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "define"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the elif variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveElif :: Typed.TypedTerm Syntax.ElifDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveElif x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "elif"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the else variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveElse :: Typed.TypedTerm Syntax.ElseDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveElse x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "else"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the endif variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveEndif :: Typed.TypedTerm Syntax.EndifDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveEndif x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "endif"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the error variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveError :: Typed.TypedTerm Syntax.ErrorDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveError x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "error"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the if variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveIf :: Typed.TypedTerm Syntax.IfDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveIf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "if"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ifdef variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveIfdef :: Typed.TypedTerm Syntax.IfdefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveIfdef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ifdef"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ifndef variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveIfndef :: Typed.TypedTerm Syntax.IfndefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveIfndef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ifndef"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the include variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveInclude :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveInclude x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "include"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the line variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveLine :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveLine x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "line"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pragma variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectivePragma :: Typed.TypedTerm Syntax.PragmaDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectivePragma x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pragma"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectivePreprocessorDirective :: Typed.TypedName Syntax.PreprocessorDirective +preprocessorDirectivePreprocessorDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective") + +-- | DSL injection for the undef variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveUndef :: Typed.TypedTerm Syntax.UndefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveUndef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "undef"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the warning variant of hydra.ext.cpp.syntax.PreprocessorDirective +preprocessorDirectiveWarning :: Typed.TypedTerm Syntax.WarningDirective -> Typed.TypedTerm Syntax.PreprocessorDirective +preprocessorDirectiveWarning x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "warning"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the identifier variant of hydra.ext.cpp.syntax.PrimaryExpression +primaryExpressionIdentifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lambda variant of hydra.ext.cpp.syntax.PrimaryExpression +primaryExpressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionLambda x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lambda"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the literal variant of hydra.ext.cpp.syntax.PrimaryExpression +primaryExpressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionLiteral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "literal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parenthesized variant of hydra.ext.cpp.syntax.PrimaryExpression +primaryExpressionParenthesized :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionParenthesized x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parenthesized"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.PrimaryExpression +primaryExpressionPrimaryExpression :: Typed.TypedName Syntax.PrimaryExpression +primaryExpressionPrimaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression") + +-- | DSL constructor for hydra.ext.cpp.syntax.ProductDeclaration +productDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.VariableDeclaration] -> Typed.TypedTerm Syntax.ProductDeclaration +productDeclaration name fields = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}]})) + +-- | DSL accessor for the fields field of hydra.ext.cpp.syntax.ProductDeclaration +productDeclarationFields :: Typed.TypedTerm Syntax.ProductDeclaration -> Typed.TypedTerm [Syntax.VariableDeclaration] +productDeclarationFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.ProductDeclaration +productDeclarationName :: Typed.TypedTerm Syntax.ProductDeclaration -> Typed.TypedTerm String +productDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.ProductDeclaration +productDeclarationProductDeclaration :: Typed.TypedName Syntax.ProductDeclaration +productDeclarationProductDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration") + +-- | DSL updater for the fields field of hydra.ext.cpp.syntax.ProductDeclaration +productDeclarationWithFields :: Typed.TypedTerm Syntax.ProductDeclaration -> Typed.TypedTerm [Syntax.VariableDeclaration] -> Typed.TypedTerm Syntax.ProductDeclaration +productDeclarationWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.ProductDeclaration +productDeclarationWithName :: Typed.TypedTerm Syntax.ProductDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ProductDeclaration +productDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Program +program :: Typed.TypedTerm [Syntax.PreprocessorDirective] -> Typed.TypedTerm [Syntax.IncludeDirective] -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Program +program preprocessorDirectives includes declarations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "preprocessorDirectives"), + Model.fieldTerm = (Typed.unTypedTerm preprocessorDirectives)}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Typed.unTypedTerm includes)}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Typed.unTypedTerm declarations)}]})) + +-- | DSL accessor for the declarations field of hydra.ext.cpp.syntax.Program +programDeclarations :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.Declaration] +programDeclarations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "declarations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the includes field of hydra.ext.cpp.syntax.Program +programIncludes :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.IncludeDirective] +programIncludes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "includes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the preprocessorDirectives field of hydra.ext.cpp.syntax.Program +programPreprocessorDirectives :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.PreprocessorDirective] +programPreprocessorDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "preprocessorDirectives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Program +programProgram :: Typed.TypedName Syntax.Program +programProgram = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Program") + +-- | DSL updater for the declarations field of hydra.ext.cpp.syntax.Program +programWithDeclarations :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Program +programWithDeclarations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "preprocessorDirectives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "preprocessorDirectives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "includes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the includes field of hydra.ext.cpp.syntax.Program +programWithIncludes :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.IncludeDirective] -> Typed.TypedTerm Syntax.Program +programWithIncludes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "preprocessorDirectives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "preprocessorDirectives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "declarations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the preprocessorDirectives field of hydra.ext.cpp.syntax.Program +programWithPreprocessorDirectives :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.PreprocessorDirective] -> Typed.TypedTerm Syntax.Program +programWithPreprocessorDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "preprocessorDirectives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "includes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"), + Model.projectionFieldName = (Model.Name "declarations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifier :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedIdentifier +qualifiedIdentifier namespace name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifierName :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm String +qualifiedIdentifierName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespace field of hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifierNamespace :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm String +qualifiedIdentifierNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifierQualifiedIdentifier :: Typed.TypedName Syntax.QualifiedIdentifier +qualifiedIdentifierQualifiedIdentifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier") + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifierWithName :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedIdentifier +qualifiedIdentifierWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the namespace field of hydra.ext.cpp.syntax.QualifiedIdentifier +qualifiedIdentifierWithNamespace :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedIdentifier +qualifiedIdentifierWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.QualifiedType +qualifiedType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeQualifier -> Typed.TypedTerm Syntax.QualifiedType +qualifiedType baseType qualifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "baseType"), + Model.fieldTerm = (Typed.unTypedTerm baseType)}, + Model.Field { + Model.fieldName = (Model.Name "qualifier"), + Model.fieldTerm = (Typed.unTypedTerm qualifier)}]})) + +-- | DSL accessor for the baseType field of hydra.ext.cpp.syntax.QualifiedType +qualifiedTypeBaseType :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeExpression +qualifiedTypeBaseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.projectionFieldName = (Model.Name "baseType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.QualifiedType +qualifiedTypeQualifiedType :: Typed.TypedName Syntax.QualifiedType +qualifiedTypeQualifiedType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.QualifiedType") + +-- | DSL accessor for the qualifier field of hydra.ext.cpp.syntax.QualifiedType +qualifiedTypeQualifier :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeQualifier +qualifiedTypeQualifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.projectionFieldName = (Model.Name "qualifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the baseType field of hydra.ext.cpp.syntax.QualifiedType +qualifiedTypeWithBaseType :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.QualifiedType +qualifiedTypeWithBaseType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "baseType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "qualifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.projectionFieldName = (Model.Name "qualifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the qualifier field of hydra.ext.cpp.syntax.QualifiedType +qualifiedTypeWithQualifier :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeQualifier -> Typed.TypedTerm Syntax.QualifiedType +qualifiedTypeWithQualifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "baseType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"), + Model.projectionFieldName = (Model.Name "baseType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "qualifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.RangeForStatement +rangeForStatement :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.RangeForStatement +rangeForStatement type_ variable range body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm variable)}, + Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = (Typed.unTypedTerm range)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementBody :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Statement +rangeForStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the range field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementRange :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Expression +rangeForStatementRange x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "range")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementRangeForStatement :: Typed.TypedName Syntax.RangeForStatement +rangeForStatementRangeForStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RangeForStatement") + +-- | DSL accessor for the type field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementType :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.TypeExpression +rangeForStatementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the variable field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementVariable :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm String +rangeForStatementVariable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "variable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementWithBody :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.RangeForStatement +rangeForStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "range")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the range field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementWithRange :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RangeForStatement +rangeForStatementWithRange original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementWithType :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.RangeForStatement +rangeForStatementWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "range")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the variable field of hydra.ext.cpp.syntax.RangeForStatement +rangeForStatementWithVariable :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.RangeForStatement +rangeForStatementWithVariable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "range")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the greater variant of hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionGreater :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionGreater x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greater"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the greaterEqual variant of hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionGreaterEqual :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionGreaterEqual x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterEqual"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the less variant of hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionLess :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionLess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "less"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lessEqual variant of hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionLessEqual :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionLessEqual x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessEqual"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionRelationalExpression :: Typed.TypedName Syntax.RelationalExpression +relationalExpressionRelationalExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RelationalExpression") + +-- | DSL injection for the shift variant of hydra.ext.cpp.syntax.RelationalExpression +relationalExpressionShift :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionShift x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "shift"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperation :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.RightShiftOperation +rightShiftOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperationLeft :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression +rightShiftOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperationRight :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.AdditiveExpression +rightShiftOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperationRightShiftOperation :: Typed.TypedName Syntax.RightShiftOperation +rightShiftOperationRightShiftOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation") + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperationWithLeft :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RightShiftOperation +rightShiftOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.RightShiftOperation +rightShiftOperationWithRight :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.RightShiftOperation +rightShiftOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.SelectionStatement +selectionStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm (Maybe Syntax.Statement) -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatement condition thenBranch elseBranch = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "thenBranch"), + Model.fieldTerm = (Typed.unTypedTerm thenBranch)}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Typed.unTypedTerm elseBranch)}]})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementCondition :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Expression +selectionStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elseBranch field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementElseBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm (Maybe Syntax.Statement) +selectionStatementElseBranch x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SelectionStatement +selectionStatementSelectionStatement :: Typed.TypedName Syntax.SelectionStatement +selectionStatementSelectionStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SelectionStatement") + +-- | DSL accessor for the thenBranch field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementThenBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Statement +selectionStatementThenBranch x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "thenBranch")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementWithCondition :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "thenBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "thenBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the elseBranch field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementWithElseBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm (Maybe Syntax.Statement) -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatementWithElseBranch original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "thenBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "thenBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the thenBranch field of hydra.ext.cpp.syntax.SelectionStatement +selectionStatementWithThenBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatementWithThenBranch original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "thenBranch"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Set +set :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Set +set elementType elements = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm elements)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.SetDeclaration +setDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.SetDeclaration +setDeclaration elementType name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the elementType field of hydra.ext.cpp.syntax.SetDeclaration +setDeclarationElementType :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm Syntax.TypeExpression +setDeclarationElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.SetDeclaration +setDeclarationName :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm String +setDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SetDeclaration +setDeclarationSetDeclaration :: Typed.TypedName Syntax.SetDeclaration +setDeclarationSetDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SetDeclaration") + +-- | DSL updater for the elementType field of hydra.ext.cpp.syntax.SetDeclaration +setDeclarationWithElementType :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.SetDeclaration +setDeclarationWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.SetDeclaration +setDeclarationWithName :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.SetDeclaration +setDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the elementType field of hydra.ext.cpp.syntax.Set +setElementType :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm Syntax.TypeExpression +setElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elements field of hydra.ext.cpp.syntax.Set +setElements :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm [Syntax.Expression] +setElements x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Set +setSet :: Typed.TypedName Syntax.Set +setSet = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Set") + +-- | DSL updater for the elementType field of hydra.ext.cpp.syntax.Set +setWithElementType :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Set +setWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the elements field of hydra.ext.cpp.syntax.Set +setWithElements :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Set +setWithElements original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the additive variant of hydra.ext.cpp.syntax.ShiftExpression +shiftExpressionAdditive :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression +shiftExpressionAdditive x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "additive"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the leftShift variant of hydra.ext.cpp.syntax.ShiftExpression +shiftExpressionLeftShift :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression +shiftExpressionLeftShift x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftShift"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the rightShift variant of hydra.ext.cpp.syntax.ShiftExpression +shiftExpressionRightShift :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression +shiftExpressionRightShift x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightShift"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.ShiftExpression +shiftExpressionShiftExpression :: Typed.TypedName Syntax.ShiftExpression +shiftExpressionShiftExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ShiftExpression") + +-- | DSL constructor for the hydra.ext.cpp.syntax.SizeofExpression wrapper +sizeofExpression :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.SizeofExpression +sizeofExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.SizeofExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SizeofExpression +sizeofExpressionSizeofExpression :: Typed.TypedName Syntax.SizeofExpression +sizeofExpressionSizeofExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SizeofExpression") + +-- | DSL injection for the compound variant of hydra.ext.cpp.syntax.Statement +statementCompound :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.Statement +statementCompound x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "compound"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.Statement +statementDeclaration :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.Statement +statementDeclaration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.cpp.syntax.Statement +statementExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement +statementExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the iteration variant of hydra.ext.cpp.syntax.Statement +statementIteration :: Typed.TypedTerm Syntax.IterationStatement -> Typed.TypedTerm Syntax.Statement +statementIteration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "iteration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the jump variant of hydra.ext.cpp.syntax.Statement +statementJump :: Typed.TypedTerm Syntax.JumpStatement -> Typed.TypedTerm Syntax.Statement +statementJump x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "jump"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the labeled variant of hydra.ext.cpp.syntax.Statement +statementLabeled :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement +statementLabeled x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "labeled"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the selection variant of hydra.ext.cpp.syntax.Statement +statementSelection :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Statement +statementSelection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "selection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.Statement +statementStatement :: Typed.TypedName Syntax.Statement +statementStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Statement") + +-- | DSL injection for the switch variant of hydra.ext.cpp.syntax.Statement +statementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Statement +statementSwitch x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "switch"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.cpp.syntax.StringLiteral wrapper +stringLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.StringLiteral +stringLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.StringLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.StringLiteral +stringLiteralStringLiteral :: Typed.TypedName Syntax.StringLiteral +stringLiteralStringLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.StringLiteral") + +-- | DSL constructor for hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SubscriptOperation +subscriptOperation array index = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm array)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm index)}]})) + +-- | DSL accessor for the array field of hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperationArray :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.PostfixExpression +subscriptOperationArray x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.projectionFieldName = (Model.Name "array")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the index field of hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperationIndex :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.Expression +subscriptOperationIndex x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperationSubscriptOperation :: Typed.TypedName Syntax.SubscriptOperation +subscriptOperationSubscriptOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation") + +-- | DSL updater for the array field of hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperationWithArray :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.SubscriptOperation +subscriptOperationWithArray original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the index field of hydra.ext.cpp.syntax.SubscriptOperation +subscriptOperationWithIndex :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SubscriptOperation +subscriptOperationWithIndex original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"), + Model.projectionFieldName = (Model.Name "array")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.SubtractOperation +subtractOperation :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.SubtractOperation +subtractOperation left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.cpp.syntax.SubtractOperation +subtractOperationLeft :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.AdditiveExpression +subtractOperationLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.cpp.syntax.SubtractOperation +subtractOperationRight :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression +subtractOperationRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SubtractOperation +subtractOperationSubtractOperation :: Typed.TypedName Syntax.SubtractOperation +subtractOperationSubtractOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SubtractOperation") + +-- | DSL updater for the left field of hydra.ext.cpp.syntax.SubtractOperation +subtractOperationWithLeft :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.SubtractOperation +subtractOperationWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.cpp.syntax.SubtractOperation +subtractOperationWithRight :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.SubtractOperation +subtractOperationWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.SwitchStatement +switchStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.CaseStatement] -> Typed.TypedTerm Syntax.SwitchStatement +switchStatement value cases = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "cases"), + Model.fieldTerm = (Typed.unTypedTerm cases)}]})) + +-- | DSL accessor for the cases field of hydra.ext.cpp.syntax.SwitchStatement +switchStatementCases :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.CaseStatement] +switchStatementCases x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "cases")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.SwitchStatement +switchStatementSwitchStatement :: Typed.TypedName Syntax.SwitchStatement +switchStatementSwitchStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SwitchStatement") + +-- | DSL accessor for the value field of hydra.ext.cpp.syntax.SwitchStatement +switchStatementValue :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression +switchStatementValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the cases field of hydra.ext.cpp.syntax.SwitchStatement +switchStatementWithCases :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.CaseStatement] -> Typed.TypedTerm Syntax.SwitchStatement +switchStatementWithCases original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cases"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the value field of hydra.ext.cpp.syntax.SwitchStatement +switchStatementWithValue :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchStatement +switchStatementWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "cases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "cases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.cpp.syntax.TemplateArgument +templateArgumentTemplateArgument :: Typed.TypedName Syntax.TemplateArgument +templateArgumentTemplateArgument = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateArgument") + +-- | DSL injection for the type variant of hydra.ext.cpp.syntax.TemplateArgument +templateArgumentType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TemplateArgument +templateArgumentType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateArgument"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the value variant of hydra.ext.cpp.syntax.TemplateArgument +templateArgumentValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TemplateArgument +templateArgumentValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateArgument"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclaration :: Typed.TypedTerm Bool -> Typed.TypedTerm [String] -> Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.TemplateDeclaration +templateDeclaration inline parameters declaration = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = (Typed.unTypedTerm inline)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm declaration)}]})) + +-- | DSL accessor for the declaration field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationDeclaration :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.Declaration +templateDeclarationDeclaration x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "declaration")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the inline field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationInline :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Bool +templateDeclarationInline x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "inline")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationParameters :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm [String] +templateDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationTemplateDeclaration :: Typed.TypedName Syntax.TemplateDeclaration +templateDeclarationTemplateDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration") + +-- | DSL updater for the declaration field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationWithDeclaration :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.TemplateDeclaration +templateDeclarationWithDeclaration original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "inline")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the inline field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationWithInline :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TemplateDeclaration +templateDeclarationWithInline original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "declaration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.TemplateDeclaration +templateDeclarationWithParameters :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm [String] -> Typed.TypedTerm Syntax.TemplateDeclaration +templateDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "inline")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"), + Model.projectionFieldName = (Model.Name "declaration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation +templateFunctionCallOperation function templateArguments arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm function)}, + Model.Field { + Model.fieldName = (Model.Name "templateArguments"), + Model.fieldTerm = (Typed.unTypedTerm templateArguments)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.Expression] +templateFunctionCallOperationArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the function field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationFunction :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression +templateFunctionCallOperationFunction x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the templateArguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationTemplateArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.TemplateArgument] +templateFunctionCallOperationTemplateArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "templateArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationTemplateFunctionCallOperation :: Typed.TypedName Syntax.TemplateFunctionCallOperation +templateFunctionCallOperationTemplateFunctionCallOperation = + Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation") + +-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "templateArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "templateArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the function field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithFunction :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithFunction original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "templateArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "templateArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the templateArguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithTemplateArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation +templateFunctionCallOperationWithTemplateArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "templateArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.TemplateType +templateType :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm Syntax.TemplateType +templateType name arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.TemplateType +templateTypeArguments :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm [Syntax.TemplateArgument] +templateTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.TemplateType +templateTypeName :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm String +templateTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.TemplateType +templateTypeTemplateType :: Typed.TypedName Syntax.TemplateType +templateTypeTemplateType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateType") + +-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.TemplateType +templateTypeWithArguments :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm Syntax.TemplateType +templateTypeWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.TemplateType +templateTypeWithName :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.TemplateType +templateTypeWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.TernaryExpression +ternaryExpression :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.TernaryExpression +ternaryExpression condition trueExpr falseExpr = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "trueExpr"), + Model.fieldTerm = (Typed.unTypedTerm trueExpr)}, + Model.Field { + Model.fieldName = (Model.Name "falseExpr"), + Model.fieldTerm = (Typed.unTypedTerm falseExpr)}]})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionCondition :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.LogicalOrExpression +ternaryExpressionCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the falseExpr field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionFalseExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.ConditionalExpression +ternaryExpressionFalseExpr x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "falseExpr")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionTernaryExpression :: Typed.TypedName Syntax.TernaryExpression +ternaryExpressionTernaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TernaryExpression") + +-- | DSL accessor for the trueExpr field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionTrueExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.Expression +ternaryExpressionTrueExpr x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "trueExpr")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionWithCondition :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.TernaryExpression +ternaryExpressionWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "trueExpr"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "trueExpr")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "falseExpr"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "falseExpr")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the falseExpr field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionWithFalseExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.TernaryExpression +ternaryExpressionWithFalseExpr original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "trueExpr"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "trueExpr")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "falseExpr"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the trueExpr field of hydra.ext.cpp.syntax.TernaryExpression +ternaryExpressionWithTrueExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TernaryExpression +ternaryExpressionWithTrueExpr original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "trueExpr"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "falseExpr"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"), + Model.projectionFieldName = (Model.Name "falseExpr")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the auto variant of hydra.ext.cpp.syntax.TypeExpression +typeExpressionAuto :: Typed.TypedTerm Syntax.TypeExpression +typeExpressionAuto = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "auto"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the basic variant of hydra.ext.cpp.syntax.TypeExpression +typeExpressionBasic :: Typed.TypedTerm Syntax.BasicType -> Typed.TypedTerm Syntax.TypeExpression +typeExpressionBasic x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "basic"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the function variant of hydra.ext.cpp.syntax.TypeExpression +typeExpressionFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.TypeExpression +typeExpressionFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the qualified variant of hydra.ext.cpp.syntax.TypeExpression +typeExpressionQualified :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeExpression +typeExpressionQualified x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "qualified"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the template variant of hydra.ext.cpp.syntax.TypeExpression +typeExpressionTemplate :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm Syntax.TypeExpression +typeExpressionTemplate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "template"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.TypeExpression +typeExpressionTypeExpression :: Typed.TypedName Syntax.TypeExpression +typeExpressionTypeExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypeExpression") + +-- | DSL injection for the const variant of hydra.ext.cpp.syntax.TypeQualifier +typeQualifierConst :: Typed.TypedTerm Syntax.TypeQualifier +typeQualifierConst = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "const"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lvalueRef variant of hydra.ext.cpp.syntax.TypeQualifier +typeQualifierLvalueRef :: Typed.TypedTerm Syntax.TypeQualifier +typeQualifierLvalueRef = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lvalueRef"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the pointer variant of hydra.ext.cpp.syntax.TypeQualifier +typeQualifierPointer :: Typed.TypedTerm Syntax.TypeQualifier +typeQualifierPointer = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rvalueRef variant of hydra.ext.cpp.syntax.TypeQualifier +typeQualifierRvalueRef :: Typed.TypedTerm Syntax.TypeQualifier +typeQualifierRvalueRef = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rvalueRef"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.TypeQualifier +typeQualifierTypeQualifier :: Typed.TypedName Syntax.TypeQualifier +typeQualifierTypeQualifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypeQualifier") + +-- | DSL constructor for hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypedefDeclaration +typedefDeclaration name type_ isUsing = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "isUsing"), + Model.fieldTerm = (Typed.unTypedTerm isUsing)}]})) + +-- | DSL accessor for the isUsing field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationIsUsing :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Bool +typedefDeclarationIsUsing x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "isUsing")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationName :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm String +typedefDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationType :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Syntax.TypeExpression +typedefDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationTypedefDeclaration :: Typed.TypedName Syntax.TypedefDeclaration +typedefDeclarationTypedefDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration") + +-- | DSL updater for the isUsing field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationWithIsUsing :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypedefDeclaration +typedefDeclarationWithIsUsing original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUsing"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationWithName :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.TypedefDeclaration +typedefDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isUsing"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "isUsing")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.cpp.syntax.TypedefDeclaration +typedefDeclarationWithType :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypedefDeclaration +typedefDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isUsing"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"), + Model.projectionFieldName = (Model.Name "isUsing")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.BooleanLiteral +unBooleanLiteral :: Typed.TypedTerm Syntax.BooleanLiteral -> Typed.TypedTerm Bool +unBooleanLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.BooleanLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.CharacterLiteral +unCharacterLiteral :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm String +unCharacterLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.CharacterLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.ClassBody +unClassBody :: Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm [Syntax.MemberSpecification] +unClassBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.ClassBody")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.CompoundStatement +unCompoundStatement :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm [Syntax.Statement] +unCompoundStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.CompoundStatement")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.ExpressionStatement +unExpressionStatement :: Typed.TypedTerm Syntax.ExpressionStatement -> Typed.TypedTerm Syntax.Expression +unExpressionStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.ExpressionStatement")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.FloatingLiteral +unFloatingLiteral :: Typed.TypedTerm Syntax.FloatingLiteral -> Typed.TypedTerm Double +unFloatingLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.FloatingLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.OverloadedLambdas +unOverloadedLambdas :: Typed.TypedTerm Syntax.OverloadedLambdas -> Typed.TypedTerm [Syntax.LambdaExpression] +unOverloadedLambdas x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.OverloadedLambdas")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.SizeofExpression +unSizeofExpression :: Typed.TypedTerm Syntax.SizeofExpression -> Typed.TypedTerm Syntax.TypeExpression +unSizeofExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.SizeofExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.cpp.syntax.StringLiteral +unStringLiteral :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm String +unStringLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.cpp.syntax.StringLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the postfix variant of hydra.ext.cpp.syntax.UnaryExpression +unaryExpressionPostfix :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPostfix x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postfix"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the sizeof variant of hydra.ext.cpp.syntax.UnaryExpression +unaryExpressionSizeof :: Typed.TypedTerm Syntax.SizeofExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionSizeof x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sizeof"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.UnaryExpression +unaryExpressionUnaryExpression :: Typed.TypedName Syntax.UnaryExpression +unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryExpression") + +-- | DSL injection for the unaryOp variant of hydra.ext.cpp.syntax.UnaryExpression +unaryExpressionUnaryOp :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionUnaryOp x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unaryOp"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.cpp.syntax.UnaryOperation +unaryOperation :: Typed.TypedTerm Syntax.UnaryOperator -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryOperation +unaryOperation operator operand = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "operand"), + Model.fieldTerm = (Typed.unTypedTerm operand)}]})) + +-- | DSL accessor for the operand field of hydra.ext.cpp.syntax.UnaryOperation +unaryOperationOperand :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpression +unaryOperationOperand x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.projectionFieldName = (Model.Name "operand")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.cpp.syntax.UnaryOperation +unaryOperationOperator :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryOperator +unaryOperationOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.UnaryOperation +unaryOperationUnaryOperation :: Typed.TypedName Syntax.UnaryOperation +unaryOperationUnaryOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryOperation") + +-- | DSL updater for the operand field of hydra.ext.cpp.syntax.UnaryOperation +unaryOperationWithOperand :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryOperation +unaryOperationWithOperand original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operand"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the operator field of hydra.ext.cpp.syntax.UnaryOperation +unaryOperationWithOperator :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryOperator -> Typed.TypedTerm Syntax.UnaryOperation +unaryOperationWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operand"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"), + Model.projectionFieldName = (Model.Name "operand")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the addressOf variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorAddressOf :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorAddressOf = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "addressOf"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bitwiseNot variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorBitwiseNot :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorBitwiseNot = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseNot"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dereference variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorDereference :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorDereference = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dereference"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the logicalNot variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorLogicalNot :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorLogicalNot = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "logicalNot"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minus variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorMinus :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorMinus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plus variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorPlus :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorPlus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preDecrement variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorPreDecrement :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorPreDecrement = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preDecrement"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preIncrement variant of hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorPreIncrement :: Typed.TypedTerm Syntax.UnaryOperator +unaryOperatorPreIncrement = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preIncrement"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.cpp.syntax.UnaryOperator +unaryOperatorUnaryOperator :: Typed.TypedName Syntax.UnaryOperator +unaryOperatorUnaryOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryOperator") + +-- | DSL constructor for hydra.ext.cpp.syntax.UndefDirective +undefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.UndefDirective +undefDirective name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UndefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.UndefDirective +undefDirectiveName :: Typed.TypedTerm Syntax.UndefDirective -> Typed.TypedTerm String +undefDirectiveName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UndefDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.UndefDirective +undefDirectiveUndefDirective :: Typed.TypedName Syntax.UndefDirective +undefDirectiveUndefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UndefDirective") + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.UndefDirective +undefDirectiveWithName :: Typed.TypedTerm Syntax.UndefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.UndefDirective +undefDirectiveWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UndefDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.VariableDeclaration +variableDeclaration :: Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableDeclaration +variableDeclaration type_ name initializer isAuto = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}, + Model.Field { + Model.fieldName = (Model.Name "isAuto"), + Model.fieldTerm = (Typed.unTypedTerm isAuto)}]})) + +-- | DSL accessor for the initializer field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationInitializer :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.Expression) +variableDeclarationInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isAuto field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationIsAuto :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Bool +variableDeclarationIsAuto x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "isAuto")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationName :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm String +variableDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationType :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeExpression) +variableDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationVariableDeclaration :: Typed.TypedName Syntax.VariableDeclaration +variableDeclarationVariableDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration") + +-- | DSL updater for the initializer field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationWithInitializer :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.VariableDeclaration +variableDeclarationWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isAuto"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "isAuto")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isAuto field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationWithIsAuto :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableDeclaration +variableDeclarationWithIsAuto original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isAuto"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationWithName :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.VariableDeclaration +variableDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isAuto"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "isAuto")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.cpp.syntax.VariableDeclaration +variableDeclarationWithType :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.VariableDeclaration +variableDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isAuto"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"), + Model.projectionFieldName = (Model.Name "isAuto")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.VariantDeclaration +variantDeclaration :: Typed.TypedTerm [Syntax.TypeExpression] -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.VariantDeclaration +variantDeclaration types name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Typed.unTypedTerm types)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the name field of hydra.ext.cpp.syntax.VariantDeclaration +variantDeclarationName :: Typed.TypedTerm Syntax.VariantDeclaration -> Typed.TypedTerm String +variantDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the types field of hydra.ext.cpp.syntax.VariantDeclaration +variantDeclarationTypes :: Typed.TypedTerm Syntax.VariantDeclaration -> Typed.TypedTerm [Syntax.TypeExpression] +variantDeclarationTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.VariantDeclaration +variantDeclarationVariantDeclaration :: Typed.TypedName Syntax.VariantDeclaration +variantDeclarationVariantDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration") + +-- | DSL updater for the name field of hydra.ext.cpp.syntax.VariantDeclaration +variantDeclarationWithName :: Typed.TypedTerm Syntax.VariantDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.VariantDeclaration +variantDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the types field of hydra.ext.cpp.syntax.VariantDeclaration +variantDeclarationWithTypes :: Typed.TypedTerm Syntax.VariantDeclaration -> Typed.TypedTerm [Syntax.TypeExpression] -> Typed.TypedTerm Syntax.VariantDeclaration +variantDeclarationWithTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.Vector +vector :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Vector +vector elementType elements = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm elements)}]})) + +-- | DSL accessor for the elementType field of hydra.ext.cpp.syntax.Vector +vectorElementType :: Typed.TypedTerm Syntax.Vector -> Typed.TypedTerm Syntax.TypeExpression +vectorElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elements field of hydra.ext.cpp.syntax.Vector +vectorElements :: Typed.TypedTerm Syntax.Vector -> Typed.TypedTerm [Syntax.Expression] +vectorElements x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.Vector +vectorVector :: Typed.TypedName Syntax.Vector +vectorVector = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Vector") + +-- | DSL updater for the elementType field of hydra.ext.cpp.syntax.Vector +vectorWithElementType :: Typed.TypedTerm Syntax.Vector -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Vector +vectorWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the elements field of hydra.ext.cpp.syntax.Vector +vectorWithElements :: Typed.TypedTerm Syntax.Vector -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Vector +vectorWithElements original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the lambda variant of hydra.ext.cpp.syntax.Visitor +visitorLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Visitor +visitorLambda x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Visitor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lambda"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the overloaded variant of hydra.ext.cpp.syntax.Visitor +visitorOverloaded :: Typed.TypedTerm Syntax.OverloadedLambdas -> Typed.TypedTerm Syntax.Visitor +visitorOverloaded x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Visitor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "overloaded"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.cpp.syntax.Visitor +visitorVisitor :: Typed.TypedName Syntax.Visitor +visitorVisitor = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Visitor") + +-- | DSL constructor for hydra.ext.cpp.syntax.WarningDirective +warningDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.WarningDirective +warningDirective message = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WarningDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "message"), + Model.fieldTerm = (Typed.unTypedTerm message)}]})) + +-- | DSL accessor for the message field of hydra.ext.cpp.syntax.WarningDirective +warningDirectiveMessage :: Typed.TypedTerm Syntax.WarningDirective -> Typed.TypedTerm String +warningDirectiveMessage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.WarningDirective"), + Model.projectionFieldName = (Model.Name "message")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.WarningDirective +warningDirectiveWarningDirective :: Typed.TypedName Syntax.WarningDirective +warningDirectiveWarningDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.WarningDirective") + +-- | DSL updater for the message field of hydra.ext.cpp.syntax.WarningDirective +warningDirectiveWithMessage :: Typed.TypedTerm Syntax.WarningDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.WarningDirective +warningDirectiveWithMessage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WarningDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "message"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.cpp.syntax.WhileStatement +whileStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement +whileStatement condition body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.cpp.syntax.WhileStatement +whileStatementBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement +whileStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the condition field of hydra.ext.cpp.syntax.WhileStatement +whileStatementCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Expression +whileStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.cpp.syntax.WhileStatement +whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement +whileStatementWhileStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.WhileStatement") + +-- | DSL updater for the body field of hydra.ext.cpp.syntax.WhileStatement +whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement +whileStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the condition field of hydra.ext.cpp.syntax.WhileStatement +whileStatementWithCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.WhileStatement +whileStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Csharp/Syntax.hs b/src/main/haskell/Hydra/Ext/Dsl/Csharp/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Csharp/Syntax.hs @@ -0,0 +1,26317 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.csharp.syntax + +module Hydra.Ext.Dsl.Csharp.Syntax where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Csharp.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL name token for hydra.ext.csharp.syntax.AccessorBody +accessorBodyAccessorBody :: Typed.TypedName Syntax.AccessorBody +accessorBodyAccessorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorBody") + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.AccessorBody +accessorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AccessorBody +accessorBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.AccessorBody +accessorBodyEmpty :: Typed.TypedTerm Syntax.AccessorBody +accessorBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.AccessorBody +accessorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AccessorBody +accessorBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.AccessorBody -> Typed.TypedTerm Syntax.AccessorDeclaration +accessorDeclaration attributes modifier body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm modifier)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationAccessorDeclaration :: Typed.TypedName Syntax.AccessorDeclaration +accessorDeclarationAccessorDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration") + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationAttributes :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +accessorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationBody :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm Syntax.AccessorBody +accessorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationModifier :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) +accessorDeclarationModifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AccessorDeclaration +accessorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationWithBody :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm Syntax.AccessorBody -> Typed.TypedTerm Syntax.AccessorDeclaration +accessorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.AccessorDeclaration +accessorDeclarationWithModifier :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.AccessorDeclaration +accessorDeclarationWithModifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AccessorDeclarations +accessorDeclarationsAccessorDeclarations :: Typed.TypedName Syntax.AccessorDeclarations +accessorDeclarationsAccessorDeclarations = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations") + +-- | DSL injection for the get variant of hydra.ext.csharp.syntax.AccessorDeclarations +accessorDeclarationsGet :: Typed.TypedTerm (Maybe Syntax.AccessorDeclaration) -> Typed.TypedTerm Syntax.AccessorDeclarations +accessorDeclarationsGet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "get"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the set variant of hydra.ext.csharp.syntax.AccessorDeclarations +accessorDeclarationsSet :: Typed.TypedTerm (Maybe Syntax.AccessorDeclaration) -> Typed.TypedTerm Syntax.AccessorDeclarations +accessorDeclarationsSet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AccessorModifier +accessorModifierAccessorModifier :: Typed.TypedName Syntax.AccessorModifier +accessorModifierAccessorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierInternal :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the internalProtected variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierInternalProtected :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierInternalProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internalProtected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierPrivate :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the privateProtected variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierPrivateProtected :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierPrivateProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "privateProtected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierProtected :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protectedInternal variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierProtectedInternal :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierProtectedInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protectedInternal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protectedPrivate variant of hydra.ext.csharp.syntax.AccessorModifier +accessorModifierProtectedPrivate :: Typed.TypedTerm Syntax.AccessorModifier +accessorModifierProtectedPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protectedPrivate"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.EventAccessorDeclarations -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclaration attributes modifiers type_ name accessors = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm accessors)}]})) + +-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations +accessorsEventDeclarationAccessors x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationAccessorsEventDeclaration :: Typed.TypedName Syntax.AccessorsEventDeclaration +accessorsEventDeclarationAccessorsEventDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration") + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationAttributes :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +accessorsEventDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationModifiers :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] +accessorsEventDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationName :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.MemberName +accessorsEventDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationType :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.Type +accessorsEventDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithAccessors original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithModifiers :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithName :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithType :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AccessorsEventDeclaration +accessorsEventDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclaration attributes body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationAddRemoveAccessorDeclaration :: Typed.TypedName Syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationAddRemoveAccessorDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration") + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationAttributes :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +addRemoveAccessorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationBody :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.Block +addRemoveAccessorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationWithBody :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration +addRemoveAccessorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AdditiveExpression +additiveExpressionAdditiveExpression :: Typed.TypedName Syntax.AdditiveExpression +additiveExpressionAdditiveExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression") + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.AdditiveExpression +additiveExpressionBinary :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression +additiveExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AdditiveExpression +additiveExpressionSimple :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression +additiveExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AdditiveOperator +additiveOperatorAdditiveOperator :: Typed.TypedName Syntax.AdditiveOperator +additiveOperatorAdditiveOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator") + +-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.AdditiveOperator +additiveOperatorMinus :: Typed.TypedTerm Syntax.AdditiveOperator +additiveOperatorMinus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.AdditiveOperator +additiveOperatorPlus :: Typed.TypedTerm Syntax.AdditiveOperator +additiveOperatorPlus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AndExpression +andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression +andExpressionAndExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AndExpression") + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.AndExpression +andExpressionBinary :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression +andExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AndExpression +andExpressionSimple :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.AndExpression +andExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionBody +anonymousFunctionBodyAnonymousFunctionBody :: Typed.TypedName Syntax.AnonymousFunctionBody +anonymousFunctionBodyAnonymousFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody") + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.AnonymousFunctionBody +anonymousFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousFunctionBody +anonymousFunctionBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.AnonymousFunctionBody +anonymousFunctionBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AnonymousFunctionBody +anonymousFunctionBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.AnonymousFunctionBody +anonymousFunctionBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody +anonymousFunctionBodyNullConditionalInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalInvocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.AnonymousFunctionBody +anonymousFunctionBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.AnonymousFunctionBody +anonymousFunctionBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierAnonymousFunctionParameterModifier :: Typed.TypedName Syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierAnonymousFunctionParameterModifier = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier") + +-- | DSL injection for the in variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierIn :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierIn = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the out variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierOut :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierOut = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "out"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierRef :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier +anonymousFunctionParameterModifierRef = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionSignature +anonymousFunctionSignatureAnonymousFunctionSignature :: Typed.TypedName Syntax.AnonymousFunctionSignature +anonymousFunctionSignatureAnonymousFunctionSignature = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature") + +-- | DSL injection for the explicit variant of hydra.ext.csharp.syntax.AnonymousFunctionSignature +anonymousFunctionSignatureExplicit :: Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.AnonymousFunctionSignature +anonymousFunctionSignatureExplicit x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "explicit"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the implicit variant of hydra.ext.csharp.syntax.AnonymousFunctionSignature +anonymousFunctionSignatureImplicit :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.AnonymousFunctionSignature +anonymousFunctionSignatureImplicit x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "implicit"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousMethodExpression +anonymousMethodExpression async signature body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Typed.unTypedTerm async)}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Typed.unTypedTerm signature)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionAnonymousMethodExpression :: Typed.TypedName Syntax.AnonymousMethodExpression +anonymousMethodExpressionAnonymousMethodExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression") + +-- | DSL accessor for the async field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionAsync :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Bool +anonymousMethodExpressionAsync x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionBody :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.Block +anonymousMethodExpressionBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the signature field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionSignature :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] +anonymousMethodExpressionSignature x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the async field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionWithAsync :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AnonymousMethodExpression +anonymousMethodExpressionWithAsync original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionWithBody :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousMethodExpression +anonymousMethodExpressionWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the signature field of hydra.ext.csharp.syntax.AnonymousMethodExpression +anonymousMethodExpressionWithSignature :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.AnonymousMethodExpression +anonymousMethodExpressionWithSignature original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.Argument +argument :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ArgumentValue -> Typed.TypedTerm Syntax.Argument +argument name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.Argument +argumentArgument :: Typed.TypedName Syntax.Argument +argumentArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Argument") + +-- | DSL constructor for the hydra.ext.csharp.syntax.ArgumentList wrapper +argumentList :: Typed.TypedTerm [Syntax.Argument] -> Typed.TypedTerm Syntax.ArgumentList +argumentList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArgumentList +argumentListArgumentList :: Typed.TypedName Syntax.ArgumentList +argumentListArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArgumentList") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.Argument +argumentName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm (Maybe Syntax.Identifier) +argumentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the value field of hydra.ext.csharp.syntax.Argument +argumentValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.ArgumentValue +argumentValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArgumentValue +argumentValueArgumentValue :: Typed.TypedName Syntax.ArgumentValue +argumentValueArgumentValue = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArgumentValue") + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ArgumentValue +argumentValueExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ArgumentValue +argumentValueExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the in variant of hydra.ext.csharp.syntax.ArgumentValue +argumentValueIn :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue +argumentValueIn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the out variant of hydra.ext.csharp.syntax.ArgumentValue +argumentValueOut :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue +argumentValueOut x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "out"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ArgumentValue +argumentValueRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue +argumentValueRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.Argument +argumentWithName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Argument +argumentWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.csharp.syntax.Argument +argumentWithValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.ArgumentValue -> Typed.TypedTerm Syntax.Argument +argumentWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArrayCreationExpression +arrayCreationExpressionArrayCreationExpression :: Typed.TypedName Syntax.ArrayCreationExpression +arrayCreationExpressionArrayCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression") + +-- | DSL injection for the arrayType variant of hydra.ext.csharp.syntax.ArrayCreationExpression +arrayCreationExpressionArrayType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression +arrayCreationExpressionArrayType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "arrayType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nonArrayType variant of hydra.ext.csharp.syntax.ArrayCreationExpression +arrayCreationExpressionNonArrayType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression +arrayCreationExpressionNonArrayType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nonArrayType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the rankSpecifier variant of hydra.ext.csharp.syntax.ArrayCreationExpression +arrayCreationExpressionRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression +arrayCreationExpressionRankSpecifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rankSpecifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.ArrayInitializer wrapper +arrayInitializer :: Typed.TypedTerm [Syntax.VariableInitializer] -> Typed.TypedTerm Syntax.ArrayInitializer +arrayInitializer x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArrayInitializer +arrayInitializerArrayInitializer :: Typed.TypedName Syntax.ArrayInitializer +arrayInitializerArrayInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer") + +-- | DSL constructor for hydra.ext.csharp.syntax.ArrayType +arrayType :: Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.ArrayType +arrayType type_ rank = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "rank"), + Model.fieldTerm = (Typed.unTypedTerm rank)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpression :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpression type_ initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionArrayTypeArrayCreationExpression :: Typed.TypedName Syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionArrayTypeArrayCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression") + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer +arrayTypeArrayCreationExpressionInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayType +arrayTypeArrayCreationExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionWithType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression +arrayTypeArrayCreationExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ArrayType +arrayTypeArrayType :: Typed.TypedName Syntax.ArrayType +arrayTypeArrayType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayType") + +-- | DSL accessor for the rank field of hydra.ext.csharp.syntax.ArrayType +arrayTypeRank :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm [Syntax.RankSpecifier] +arrayTypeRank x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.projectionFieldName = (Model.Name "rank")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ArrayType +arrayTypeType :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.NonArrayType +arrayTypeType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the rank field of hydra.ext.csharp.syntax.ArrayType +arrayTypeWithRank :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.ArrayType +arrayTypeWithRank original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rank"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ArrayType +arrayTypeWithType :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.ArrayType +arrayTypeWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rank"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"), + Model.projectionFieldName = (Model.Name "rank")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AsTypeExpression +asTypeExpression expression type_ = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpressionAsTypeExpression :: Typed.TypedName Syntax.AsTypeExpression +asTypeExpressionAsTypeExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpressionExpression :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression +asTypeExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpressionType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.Type +asTypeExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpressionWithExpression :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.AsTypeExpression +asTypeExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.AsTypeExpression +asTypeExpressionWithType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AsTypeExpression +asTypeExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.Assignment +assignment :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment +assignment left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.Assignment +assignmentAssignment :: Typed.TypedName Syntax.Assignment +assignmentAssignment = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Assignment") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.Assignment +assignmentLeft :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.UnaryExpression +assignmentLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator +assignmentMemberDeclarator identifier expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorAssignmentMemberDeclarator :: Typed.TypedName Syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorAssignmentMemberDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorExpression :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Expression +assignmentMemberDeclaratorExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorIdentifier :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Identifier +assignmentMemberDeclaratorIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorWithExpression :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator +assignmentMemberDeclaratorWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.Assignment +assignmentOperator :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the andEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorAndEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorAndEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "andEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorAssignmentOperator :: Typed.TypedName Syntax.AssignmentOperator +assignmentOperatorAssignmentOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator") + +-- | DSL injection for the divideEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorDivideEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorDivideEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divideEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftShiftEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorLeftShiftEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorLeftShiftEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftShiftEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minusEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorMinusEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorMinusEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minusEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the modEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorModEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorModEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the orEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorOrEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorOrEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "orEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plusEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorPlusEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorPlusEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plusEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightShiftEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorRightShiftEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorRightShiftEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightShiftEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorSimple :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the timesEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorTimesEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorTimesEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timesEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the xorEquals variant of hydra.ext.csharp.syntax.AssignmentOperator +assignmentOperatorXorEquals :: Typed.TypedTerm Syntax.AssignmentOperator +assignmentOperatorXorEquals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "xorEquals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.Assignment +assignmentRight :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression +assignmentRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.Assignment +assignmentWithLeft :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.Assignment +assignmentWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.Assignment +assignmentWithOperator :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Assignment +assignmentWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.Assignment +assignmentWithRight :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment +assignmentWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.Attribute +attribute :: Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm (Maybe Syntax.AttributeArguments) -> Typed.TypedTerm Syntax.Attribute +attribute name arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeArgumentExpression wrapper +attributeArgumentExpression :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.AttributeArgumentExpression +attributeArgumentExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeArgumentExpression +attributeArgumentExpressionAttributeArgumentExpression :: Typed.TypedName Syntax.AttributeArgumentExpression +attributeArgumentExpressionAttributeArgumentExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression") + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.Attribute +attributeArguments :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm (Maybe Syntax.AttributeArguments) +attributeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.AttributeArguments +attributeArguments2 :: Typed.TypedTerm (Maybe Syntax.PositionalArgumentList) -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments +attributeArguments2 positonal named = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "positonal"), + Model.fieldTerm = (Typed.unTypedTerm positonal)}, + Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm named)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeArguments +attributeArgumentsAttributeArguments :: Typed.TypedName Syntax.AttributeArguments +attributeArgumentsAttributeArguments = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeArguments") + +-- | DSL accessor for the named field of hydra.ext.csharp.syntax.AttributeArguments +attributeArgumentsNamed :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList) +attributeArgumentsNamed x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.projectionFieldName = (Model.Name "named")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the positonal field of hydra.ext.csharp.syntax.AttributeArguments +attributeArgumentsPositonal :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.PositionalArgumentList) +attributeArgumentsPositonal x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.projectionFieldName = (Model.Name "positonal")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the named field of hydra.ext.csharp.syntax.AttributeArguments +attributeArgumentsWithNamed :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments +attributeArgumentsWithNamed original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "positonal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.projectionFieldName = (Model.Name "positonal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the positonal field of hydra.ext.csharp.syntax.AttributeArguments +attributeArgumentsWithPositonal :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.PositionalArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments +attributeArgumentsWithPositonal original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "positonal"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"), + Model.projectionFieldName = (Model.Name "named")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.Attribute +attributeAttribute :: Typed.TypedName Syntax.Attribute +attributeAttribute = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Attribute") + +-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeList wrapper +attributeList :: Typed.TypedTerm [Syntax.Attribute] -> Typed.TypedTerm Syntax.AttributeList +attributeList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeList +attributeListAttributeList :: Typed.TypedName Syntax.AttributeList +attributeListAttributeList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeList") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.Attribute +attributeName :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.AttributeName +attributeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeName wrapper +attributeName2 :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.AttributeName +attributeName2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeName +attributeNameAttributeName :: Typed.TypedName Syntax.AttributeName +attributeNameAttributeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeName") + +-- | DSL constructor for hydra.ext.csharp.syntax.AttributeSection +attributeSection :: Typed.TypedTerm (Maybe Syntax.AttributeTarget) -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.AttributeSection +attributeSection target attributes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeSection +attributeSectionAttributeSection :: Typed.TypedName Syntax.AttributeSection +attributeSectionAttributeSection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeSection") + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AttributeSection +attributeSectionAttributes :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm Syntax.AttributeList +attributeSectionAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the target field of hydra.ext.csharp.syntax.AttributeSection +attributeSectionTarget :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm (Maybe Syntax.AttributeTarget) +attributeSectionTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AttributeSection +attributeSectionWithAttributes :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.AttributeSection +attributeSectionWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the target field of hydra.ext.csharp.syntax.AttributeSection +attributeSectionWithTarget :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm (Maybe Syntax.AttributeTarget) -> Typed.TypedTerm Syntax.AttributeSection +attributeSectionWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.AttributeTarget +attributeTargetAttributeTarget :: Typed.TypedName Syntax.AttributeTarget +attributeTargetAttributeTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeTarget") + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.AttributeTarget +attributeTargetIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeTarget +attributeTargetIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the keyword variant of hydra.ext.csharp.syntax.AttributeTarget +attributeTargetKeyword :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm Syntax.AttributeTarget +attributeTargetKeyword x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "keyword"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.Attribute +attributeWithArguments :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm (Maybe Syntax.AttributeArguments) -> Typed.TypedTerm Syntax.Attribute +attributeWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.Attribute +attributeWithName :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm Syntax.Attribute +attributeWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.Attributes wrapper +attributes :: Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm Syntax.Attributes +attributes x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Attributes"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Attributes +attributesAttributes :: Typed.TypedName Syntax.Attributes +attributesAttributes = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Attributes") + +-- | DSL injection for the arguments variant of hydra.ext.csharp.syntax.BaseAccess +baseAccessArguments :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.BaseAccess +baseAccessArguments x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccess"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.BaseAccess +baseAccessBaseAccess :: Typed.TypedName Syntax.BaseAccess +baseAccessBaseAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BaseAccess") + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.BaseAccess +baseAccessIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.BaseAccess +baseAccessIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccess"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier +baseAccessWithIdentifier identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierBaseAccessWithIdentifier :: Typed.TypedName Syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierBaseAccessWithIdentifier = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.Identifier +baseAccessWithIdentifierIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierTypeArguments :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +baseAccessWithIdentifierTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierWithIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierWithTypeArguments :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier +baseAccessWithIdentifierWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpression :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression +binaryAdditiveExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionBinaryAdditiveExpression :: Typed.TypedName Syntax.BinaryAdditiveExpression +binaryAdditiveExpressionBinaryAdditiveExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionLeft :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression +binaryAdditiveExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionOperator :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator +binaryAdditiveExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionRight :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression +binaryAdditiveExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator -> Typed.TypedTerm Syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithRight :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression +binaryAdditiveExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpression :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryAndExpression +binaryAndExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpressionBinaryAndExpression :: Typed.TypedName Syntax.BinaryAndExpression +binaryAndExpressionBinaryAndExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpressionLeft :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression +binaryAndExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpressionRight :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.EqualityExpression +binaryAndExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryAndExpression +binaryAndExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryAndExpression +binaryAndExpressionWithRight :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryAndExpression +binaryAndExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpression :: Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression +binaryConditionalAndExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionBinaryConditionalAndExpression :: Typed.TypedName Syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionBinaryConditionalAndExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionLeft :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression +binaryConditionalAndExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionRight :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression +binaryConditionalAndExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionWithRight :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression +binaryConditionalAndExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpression :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression +binaryConditionalOrExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionBinaryConditionalOrExpression :: Typed.TypedName Syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionBinaryConditionalOrExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression +binaryConditionalOrExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionRight :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression +binaryConditionalOrExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression +binaryConditionalOrExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpression :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression +binaryEqualityExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionBinaryEqualityExpression :: Typed.TypedName Syntax.BinaryEqualityExpression +binaryEqualityExpressionBinaryEqualityExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionLeft :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression +binaryEqualityExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionOperator :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator +binaryEqualityExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionRight :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression +binaryEqualityExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression +binaryEqualityExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator -> Typed.TypedTerm Syntax.BinaryEqualityExpression +binaryEqualityExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryEqualityExpression +binaryEqualityExpressionWithRight :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression +binaryEqualityExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpression :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionBinaryExclusiveOrExpression :: Typed.TypedName Syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionBinaryExclusiveOrExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression +binaryExclusiveOrExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionRight :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression +binaryExclusiveOrExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression +binaryExclusiveOrExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpression :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionBinaryInclusiveOrExpression :: Typed.TypedName Syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionBinaryInclusiveOrExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression +binaryInclusiveOrExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionRight :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression +binaryInclusiveOrExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression +binaryInclusiveOrExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpression :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionBinaryMultiplicativeExpression :: Typed.TypedName Syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionBinaryMultiplicativeExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionLeft :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression +binaryMultiplicativeExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionOperator :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator +binaryMultiplicativeExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionRight :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression +binaryMultiplicativeExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithRight :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression +binaryMultiplicativeExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpression :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpression left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionBinaryNullCoalescingExpression :: Typed.TypedName Syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionBinaryNullCoalescingExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionLeft :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression +binaryNullCoalescingExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionRight :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +binaryNullCoalescingExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionWithRight :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression +binaryNullCoalescingExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OverloadableBinaryOperator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator +binaryOperatorDeclarator type_ operator left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorBinaryOperatorDeclarator :: Typed.TypedName Syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorBinaryOperatorDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorLeft :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter +binaryOperatorDeclaratorLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorOperator :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableBinaryOperator +binaryOperatorDeclaratorOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorRight :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter +binaryOperatorDeclaratorRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorType :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type +binaryOperatorDeclaratorType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithLeft :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithOperator :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableBinaryOperator -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithRight :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator +binaryOperatorDeclaratorWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression +binaryRelationalExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionBinaryRelationalExpression :: Typed.TypedName Syntax.BinaryRelationalExpression +binaryRelationalExpressionBinaryRelationalExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionLeft :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression +binaryRelationalExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionOperator :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator +binaryRelationalExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionRight :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression +binaryRelationalExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression +binaryRelationalExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator -> Typed.TypedTerm Syntax.BinaryRelationalExpression +binaryRelationalExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryRelationalExpression +binaryRelationalExpressionWithRight :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression +binaryRelationalExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpression :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression +binaryShiftExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionBinaryShiftExpression :: Typed.TypedName Syntax.BinaryShiftExpression +binaryShiftExpressionBinaryShiftExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression") + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionLeft :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression +binaryShiftExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionOperator :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator +binaryShiftExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionRight :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression +binaryShiftExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression +binaryShiftExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator -> Typed.TypedTerm Syntax.BinaryShiftExpression +binaryShiftExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryShiftExpression +binaryShiftExpressionWithRight :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression +binaryShiftExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.Block wrapper +block :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.Block +block x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Block"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Block +blockBlock :: Typed.TypedName Syntax.Block +blockBlock = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Block") + +-- | DSL constructor for hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBody :: Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.BlockPropertyBody +blockPropertyBody accessors initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm accessors)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBodyAccessors :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.AccessorDeclarations +blockPropertyBodyAccessors x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBodyBlockPropertyBody :: Typed.TypedName Syntax.BlockPropertyBody +blockPropertyBodyBlockPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody") + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBodyInitializer :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) +blockPropertyBodyInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBodyWithAccessors :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm Syntax.BlockPropertyBody +blockPropertyBodyWithAccessors original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.BlockPropertyBody +blockPropertyBodyWithInitializer :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.BlockPropertyBody +blockPropertyBodyWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.BooleanExpression wrapper +booleanExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BooleanExpression +booleanExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.BooleanExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.BooleanExpression +booleanExpressionBooleanExpression :: Typed.TypedName Syntax.BooleanExpression +booleanExpressionBooleanExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BooleanExpression") + +-- | DSL constructor for hydra.ext.csharp.syntax.CastExpression +castExpression :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression +castExpression type_ expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.CastExpression +castExpressionCastExpression :: Typed.TypedName Syntax.CastExpression +castExpressionCastExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CastExpression") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.CastExpression +castExpressionExpression :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression +castExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.CastExpression +castExpressionType :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.Type +castExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.CastExpression +castExpressionWithExpression :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression +castExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.CastExpression +castExpressionWithType :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.CastExpression +castExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.CatchClauses +catchClausesCatchClauses :: Typed.TypedName Syntax.CatchClauses +catchClausesCatchClauses = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CatchClauses") + +-- | DSL injection for the general variant of hydra.ext.csharp.syntax.CatchClauses +catchClausesGeneral :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClauses +catchClausesGeneral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CatchClauses"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "general"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the specific variant of hydra.ext.csharp.syntax.CatchClauses +catchClausesSpecific :: Typed.TypedTerm [Syntax.SpecificCatchClause] -> Typed.TypedTerm Syntax.CatchClauses +catchClausesSpecific x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CatchClauses"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "specific"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the class variant of hydra.ext.csharp.syntax.ClassBase +classBaseClass :: Typed.TypedTerm (Maybe Syntax.ClassType) -> Typed.TypedTerm Syntax.ClassBase +classBaseClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassBase +classBaseClassBase :: Typed.TypedName Syntax.ClassBase +classBaseClassBase = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassBase") + +-- | DSL injection for the interfaces variant of hydra.ext.csharp.syntax.ClassBase +classBaseInterfaces :: Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.ClassBase +classBaseInterfaces x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.ClassBody wrapper +classBody :: Typed.TypedTerm [Syntax.ClassMemberDeclaration] -> Typed.TypedTerm Syntax.ClassBody +classBody x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBody"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassBody +classBodyClassBody :: Typed.TypedName Syntax.ClassBody +classBodyClassBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.ClassDeclaration +classDeclaration :: Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm (Maybe Syntax.ClassBase) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclaration attributes modifiers partial name parameters base constraints body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm partial)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm base)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationAttributes :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.AttributeSection] +classDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the base field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationBase :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBase) +classDeclarationBase x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassBody +classDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationClassDeclaration :: Typed.TypedName Syntax.ClassDeclaration +classDeclarationClassDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration") + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationConstraints :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +classDeclarationConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationModifiers :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] +classDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationName :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Identifier +classDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationParameters :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) +classDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationPartial :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Bool +classDeclarationPartial x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithAttributes :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the base field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithBase :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBase) -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithBase original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithConstraints :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithModifiers :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithName :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithParameters :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the partial field of hydra.ext.csharp.syntax.ClassDeclaration +classDeclarationWithPartial :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ClassDeclaration +classDeclarationWithPartial original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationClassMemberDeclaration :: Typed.TypedName Syntax.ClassMemberDeclaration +classMemberDeclarationClassMemberDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration") + +-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationConstant x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constant"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the constructor variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the event variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationEvent :: Typed.TypedTerm Syntax.EventDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationEvent x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "event"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the field variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationField :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationField x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "field"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the finalizer variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationFinalizer :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationFinalizer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "finalizer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationIndexer :: Typed.TypedTerm Syntax.IndexerDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationIndexer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "indexer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the method variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationMethod :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "method"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the operator variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationOperator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationOperator x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the property variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationProperty :: Typed.TypedTerm Syntax.PropertyDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationProperty x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the staticConstructor variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationStaticConstructor :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationStaticConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "staticConstructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.ClassMemberDeclaration +classMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration +classMemberDeclarationType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.ClassModifier +classModifierAbstract :: Typed.TypedTerm Syntax.ClassModifier +classModifierAbstract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "abstract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassModifier +classModifierClassModifier :: Typed.TypedName Syntax.ClassModifier +classModifierClassModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ClassModifier +classModifierInternal :: Typed.TypedTerm Syntax.ClassModifier +classModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.ClassModifier +classModifierNew :: Typed.TypedTerm Syntax.ClassModifier +classModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ClassModifier +classModifierPrivate :: Typed.TypedTerm Syntax.ClassModifier +classModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ClassModifier +classModifierProtected :: Typed.TypedTerm Syntax.ClassModifier +classModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ClassModifier +classModifierPublic :: Typed.TypedTerm Syntax.ClassModifier +classModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.ClassModifier +classModifierSealed :: Typed.TypedTerm Syntax.ClassModifier +classModifierSealed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sealed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.ClassModifier +classModifierStatic :: Typed.TypedTerm Syntax.ClassModifier +classModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.ClassModifier +classModifierUnsafe :: Typed.TypedTerm Syntax.ClassModifier +classModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ClassType +classTypeClassType :: Typed.TypedName Syntax.ClassType +classTypeClassType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassType") + +-- | DSL injection for the object variant of hydra.ext.csharp.syntax.ClassType +classTypeObject :: Typed.TypedTerm Syntax.ClassType +classTypeObject = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.csharp.syntax.ClassType +classTypeString :: Typed.TypedTerm Syntax.ClassType +classTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the typeName variant of hydra.ext.csharp.syntax.ClassType +classTypeTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.ClassType +classTypeTypeName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.CompilationUnit +compilationUnit :: Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm [Syntax.GlobalAttributeSection] -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.CompilationUnit +compilationUnit externs usings attributes members = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Typed.unTypedTerm externs)}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Typed.unTypedTerm usings)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Typed.unTypedTerm members)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitAttributes :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.GlobalAttributeSection] +compilationUnitAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.CompilationUnit +compilationUnitCompilationUnit :: Typed.TypedName Syntax.CompilationUnit +compilationUnitCompilationUnit = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CompilationUnit") + +-- | DSL accessor for the externs field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitExterns :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.ExternAliasDirective] +compilationUnitExterns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the members field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitMembers :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] +compilationUnitMembers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the usings field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitUsings :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.UsingDirective] +compilationUnitUsings x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitWithAttributes :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.GlobalAttributeSection] -> Typed.TypedTerm Syntax.CompilationUnit +compilationUnitWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the externs field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitWithExterns :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm Syntax.CompilationUnit +compilationUnitWithExterns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the members field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitWithMembers :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.CompilationUnit +compilationUnitWithMembers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the usings field of hydra.ext.csharp.syntax.CompilationUnit +compilationUnitWithUsings :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm Syntax.CompilationUnit +compilationUnitWithUsings original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ConditionalAndExpression +conditionalAndExpressionBinary :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression +conditionalAndExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConditionalAndExpression +conditionalAndExpressionConditionalAndExpression :: Typed.TypedName Syntax.ConditionalAndExpression +conditionalAndExpressionConditionalAndExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalAndExpression +conditionalAndExpressionSimple :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression +conditionalAndExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConditionalExpression +conditionalExpressionConditionalExpression :: Typed.TypedName Syntax.ConditionalExpression +conditionalExpressionConditionalExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression") + +-- | DSL injection for the refConditional variant of hydra.ext.csharp.syntax.ConditionalExpression +conditionalExpressionRefConditional :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression +conditionalExpressionRefConditional x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "refConditional"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalExpression +conditionalExpressionSimple :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalExpression +conditionalExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simpleConditional variant of hydra.ext.csharp.syntax.ConditionalExpression +conditionalExpressionSimpleConditional :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression +conditionalExpressionSimpleConditional x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simpleConditional"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ConditionalOrExpression +conditionalOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression +conditionalOrExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConditionalOrExpression +conditionalOrExpressionConditionalOrExpression :: Typed.TypedName Syntax.ConditionalOrExpression +conditionalOrExpressionConditionalOrExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalOrExpression +conditionalOrExpressionSimple :: Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression +conditionalOrExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration +constantDeclaration attributes modifiers type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationAttributes :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +constantDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationConstantDeclaration :: Typed.TypedName Syntax.ConstantDeclaration +constantDeclarationConstantDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration") + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationDeclarators :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] +constantDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier] +constantDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.Type +constantDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationWithAttributes :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ConstantDeclaration +constantDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationWithDeclarators :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration +constantDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.ConstantDeclaration +constantDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ConstantDeclaration +constantDeclarationWithType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConstantDeclaration +constantDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.ConstantDeclarator +constantDeclarator identifier expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclaratorConstantDeclarator :: Typed.TypedName Syntax.ConstantDeclarator +constantDeclaratorConstantDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclaratorExpression :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.ConstantExpression +constantDeclaratorExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclaratorIdentifier :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.Identifier +constantDeclaratorIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclaratorWithExpression :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.ConstantDeclarator +constantDeclaratorWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ConstantDeclarator +constantDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantDeclarator +constantDeclaratorWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.ConstantExpression wrapper +constantExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstantExpression +constantExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstantExpression +constantExpressionConstantExpression :: Typed.TypedName Syntax.ConstantExpression +constantExpressionConstantExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantExpression") + +-- | DSL name token for hydra.ext.csharp.syntax.ConstantModifier +constantModifierConstantModifier :: Typed.TypedName Syntax.ConstantModifier +constantModifierConstantModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ConstantModifier +constantModifierInternal :: Typed.TypedTerm Syntax.ConstantModifier +constantModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.ConstantModifier +constantModifierNew :: Typed.TypedTerm Syntax.ConstantModifier +constantModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ConstantModifier +constantModifierPrivate :: Typed.TypedTerm Syntax.ConstantModifier +constantModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ConstantModifier +constantModifierProtected :: Typed.TypedTerm Syntax.ConstantModifier +constantModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ConstantModifier +constantModifierPublic :: Typed.TypedTerm Syntax.ConstantModifier +constantModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.ConstructorBody +constructorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ConstructorBody +constructorBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstructorBody +constructorBodyConstructorBody :: Typed.TypedName Syntax.ConstructorBody +constructorBodyConstructorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorBody") + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.ConstructorBody +constructorBodyEmpty :: Typed.TypedTerm Syntax.ConstructorBody +constructorBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ConstructorBody +constructorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstructorBody +constructorBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclaration attributes modifiers declarator body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm declarator)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationAttributes :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +constructorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody +constructorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationConstructorDeclaration :: Typed.TypedName Syntax.ConstructorDeclaration +constructorDeclarationConstructorDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration") + +-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationDeclarator :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator +constructorDeclarationDeclarator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier] +constructorDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationWithAttributes :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationWithBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationWithDeclarator :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithDeclarator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ConstructorDeclaration +constructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclaration +constructorDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer) -> Typed.TypedTerm Syntax.ConstructorDeclarator +constructorDeclarator name parameters initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorConstructorDeclarator :: Typed.TypedName Syntax.ConstructorDeclarator +constructorDeclaratorConstructorDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator") + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorInitializer :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer) +constructorDeclaratorInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.Identifier +constructorDeclaratorName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) +constructorDeclaratorParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorWithInitializer :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer) -> Typed.TypedTerm Syntax.ConstructorDeclarator +constructorDeclaratorWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorWithName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstructorDeclarator +constructorDeclaratorWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.ConstructorDeclarator +constructorDeclaratorWithParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.ConstructorDeclarator +constructorDeclaratorWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the base variant of hydra.ext.csharp.syntax.ConstructorInitializer +constructorInitializerBase :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ConstructorInitializer +constructorInitializerBase x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstructorInitializer +constructorInitializerConstructorInitializer :: Typed.TypedName Syntax.ConstructorInitializer +constructorInitializerConstructorInitializer = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer") + +-- | DSL injection for the this variant of hydra.ext.csharp.syntax.ConstructorInitializer +constructorInitializerThis :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ConstructorInitializer +constructorInitializerThis x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "this"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierConstructorModifier :: Typed.TypedName Syntax.ConstructorModifier +constructorModifierConstructorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier") + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierExtern :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierInternal :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierPrivate :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierProtected :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierPublic :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.ConstructorModifier +constructorModifierUnsafe :: Typed.TypedTerm Syntax.ConstructorModifier +constructorModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConversionKind +conversionKindConversionKind :: Typed.TypedName Syntax.ConversionKind +conversionKindConversionKind = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConversionKind") + +-- | DSL injection for the explicit variant of hydra.ext.csharp.syntax.ConversionKind +conversionKindExplicit :: Typed.TypedTerm Syntax.ConversionKind +conversionKindExplicit = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "explicit"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the implicit variant of hydra.ext.csharp.syntax.ConversionKind +conversionKindImplicit :: Typed.TypedTerm Syntax.ConversionKind +conversionKindImplicit = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "implicit"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclarator :: Typed.TypedTerm Syntax.ConversionKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator +conversionOperatorDeclarator kind type_ parameter = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm parameter)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorConversionOperatorDeclarator :: Typed.TypedName Syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorConversionOperatorDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator") + +-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorKind :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.ConversionKind +conversionOperatorDeclaratorKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorParameter :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter +conversionOperatorDeclaratorParameter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorType :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.Type +conversionOperatorDeclaratorType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the kind field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithKind :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.ConversionKind -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithParameter :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithParameter original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator +conversionOperatorDeclaratorWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DeclarationExpression +declarationExpression :: Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeclarationExpression +declarationExpression type_ identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.DeclarationExpression +declarationExpressionDeclarationExpression :: Typed.TypedName Syntax.DeclarationExpression +declarationExpressionDeclarationExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.DeclarationExpression +declarationExpressionIdentifier :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.Identifier +declarationExpressionIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DeclarationExpression +declarationExpressionType :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.LocalVariableType +declarationExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.DeclarationExpression +declarationExpressionWithIdentifier :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeclarationExpression +declarationExpressionWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.DeclarationExpression +declarationExpressionWithType :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.DeclarationExpression +declarationExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DeclarationPattern +declarationPattern :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.DeclarationPattern +declarationPattern type_ designation = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "designation"), + Model.fieldTerm = (Typed.unTypedTerm designation)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.DeclarationPattern +declarationPatternDeclarationPattern :: Typed.TypedName Syntax.DeclarationPattern +declarationPatternDeclarationPattern = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern") + +-- | DSL accessor for the designation field of hydra.ext.csharp.syntax.DeclarationPattern +declarationPatternDesignation :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Designation +declarationPatternDesignation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.projectionFieldName = (Model.Name "designation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DeclarationPattern +declarationPatternType :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Type +declarationPatternType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the designation field of hydra.ext.csharp.syntax.DeclarationPattern +declarationPatternWithDesignation :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.DeclarationPattern +declarationPatternWithDesignation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "designation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.DeclarationPattern +declarationPatternWithType :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DeclarationPattern +declarationPatternWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "designation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"), + Model.projectionFieldName = (Model.Name "designation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.DeclarationStatement +declarationStatementConstant :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement +declarationStatementConstant x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constant"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.DeclarationStatement +declarationStatementDeclarationStatement :: Typed.TypedName Syntax.DeclarationStatement +declarationStatementDeclarationStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement") + +-- | DSL injection for the function variant of hydra.ext.csharp.syntax.DeclarationStatement +declarationStatementFunction :: Typed.TypedTerm Syntax.LocalFunctionDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement +declarationStatementFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the variable variant of hydra.ext.csharp.syntax.DeclarationStatement +declarationStatementVariable :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement +declarationStatementVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.DeconstructionElement +deconstructionElementDeconstructionElement :: Typed.TypedName Syntax.DeconstructionElement +deconstructionElementDeconstructionElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement") + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.DeconstructionElement +deconstructionElementIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeconstructionElement +deconstructionElementIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.DeconstructionElement +deconstructionElementTuple :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm Syntax.DeconstructionElement +deconstructionElementTuple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "tuple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.DeconstructionTuple wrapper +deconstructionTuple :: Typed.TypedTerm [Syntax.DeconstructionElement] -> Typed.TypedTerm Syntax.DeconstructionTuple +deconstructionTuple x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.DeconstructionTuple +deconstructionTupleDeconstructionTuple :: Typed.TypedName Syntax.DeconstructionTuple +deconstructionTupleDeconstructionTuple = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple") + +-- | DSL injection for the defaultLiteral variant of hydra.ext.csharp.syntax.DefaultValueExpression +defaultValueExpressionDefaultLiteral :: Typed.TypedTerm Syntax.DefaultValueExpression +defaultValueExpressionDefaultLiteral = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "defaultLiteral"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.DefaultValueExpression +defaultValueExpressionDefaultValueExpression :: Typed.TypedName Syntax.DefaultValueExpression +defaultValueExpressionDefaultValueExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression") + +-- | DSL injection for the explicitlyTyped variant of hydra.ext.csharp.syntax.DefaultValueExpression +defaultValueExpressionExplicitlyTyped :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefaultValueExpression +defaultValueExpressionExplicitlyTyped x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "explicitlyTyped"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpression :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DelegateCreationExpression +delegateCreationExpression type_ expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpressionDelegateCreationExpression :: Typed.TypedName Syntax.DelegateCreationExpression +delegateCreationExpressionDelegateCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpressionExpression :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.Expression +delegateCreationExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpressionType :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.DelegateType +delegateCreationExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpressionWithExpression :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DelegateCreationExpression +delegateCreationExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.DelegateCreationExpression +delegateCreationExpressionWithType :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.DelegateCreationExpression +delegateCreationExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.DelegateModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclaration attributes modifiers returnType refKind refReturnType header = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Typed.unTypedTerm refReturnType)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationAttributes :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +delegateDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationDelegateDeclaration :: Typed.TypedName Syntax.DelegateDeclaration +delegateDeclarationDelegateDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration") + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationHeader :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.DelegateHeader +delegateDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationModifiers :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm [Syntax.DelegateModifier] +delegateDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationRefKind :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) +delegateDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refReturnType field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationRefReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Type) +delegateDeclarationRefReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.ReturnType +delegateDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithAttributes :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithHeader :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithModifiers :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm [Syntax.DelegateModifier] -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithRefKind :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refReturnType field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithRefReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithRefReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.DelegateDeclaration +delegateDeclarationWithReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.DelegateDeclaration +delegateDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refReturnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "refReturnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DelegateHeader +delegateHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.DelegateHeader +delegateHeader name typeParameters parameters constraints = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm typeParameters)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}]})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderConstraints :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +delegateHeaderConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderDelegateHeader :: Typed.TypedName Syntax.DelegateHeader +delegateHeaderDelegateHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateHeader") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderName :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.Identifier +delegateHeaderName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) +delegateHeaderParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderTypeParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) +delegateHeaderTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderWithConstraints :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.DelegateHeader +delegateHeaderWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderWithName :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DelegateHeader +delegateHeaderWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderWithParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.DelegateHeader +delegateHeaderWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.DelegateHeader +delegateHeaderWithTypeParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm Syntax.DelegateHeader +delegateHeaderWithTypeParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.DelegateModifier +delegateModifierDelegateModifier :: Typed.TypedName Syntax.DelegateModifier +delegateModifierDelegateModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierInternal :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierNew :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierPrivate :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierProtected :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierPublic :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.DelegateModifier +delegateModifierUnsafe :: Typed.TypedTerm Syntax.DelegateModifier +delegateModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.DelegateType wrapper +delegateType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.DelegateType +delegateType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.DelegateType +delegateTypeDelegateType :: Typed.TypedName Syntax.DelegateType +delegateTypeDelegateType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateType") + +-- | DSL name token for hydra.ext.csharp.syntax.DependentAccess +dependentAccessDependentAccess :: Typed.TypedName Syntax.DependentAccess +dependentAccessDependentAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DependentAccess") + +-- | DSL injection for the elementAccess variant of hydra.ext.csharp.syntax.DependentAccess +dependentAccessElementAccess :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.DependentAccess +dependentAccessElementAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "elementAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMember :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.DependentAccessForMember +dependentAccessForMember identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMemberDependentAccessForMember :: Typed.TypedName Syntax.DependentAccessForMember +dependentAccessForMemberDependentAccessForMember = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMemberIdentifier :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.Identifier +dependentAccessForMemberIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMemberTypeArguments :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +dependentAccessForMemberTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMemberWithIdentifier :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DependentAccessForMember +dependentAccessForMemberWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.DependentAccessForMember +dependentAccessForMemberWithTypeArguments :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.DependentAccessForMember +dependentAccessForMemberWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.DependentAccess +dependentAccessInvocation :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.DependentAccess +dependentAccessInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "invocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.DependentAccess +dependentAccessMemberAccess :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.DependentAccess +dependentAccessMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "memberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.Designation wrapper +designation :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Designation +designation x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Designation"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Designation +designationDesignation :: Typed.TypedName Syntax.Designation +designationDesignation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Designation") + +-- | DSL constructor for hydra.ext.csharp.syntax.DoStatement +doStatement :: Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.DoStatement +doStatement body while = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}, + Model.Field { + Model.fieldName = (Model.Name "while"), + Model.fieldTerm = (Typed.unTypedTerm while)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.DoStatement +doStatementBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +doStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.DoStatement +doStatementDoStatement :: Typed.TypedName Syntax.DoStatement +doStatementDoStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DoStatement") + +-- | DSL accessor for the while field of hydra.ext.csharp.syntax.DoStatement +doStatementWhile :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.BooleanExpression +doStatementWhile x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "while")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.DoStatement +doStatementWithBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.DoStatement +doStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "while"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "while")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the while field of hydra.ext.csharp.syntax.DoStatement +doStatementWithWhile :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.DoStatement +doStatementWithWhile original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "while"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ElementAccess +elementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.ElementAccess +elementAccess expression arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.ElementAccess +elementAccessArguments :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.ArgumentList +elementAccessArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ElementAccess +elementAccessElementAccess :: Typed.TypedName Syntax.ElementAccess +elementAccessElementAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ElementAccess") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ElementAccess +elementAccessExpression :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +elementAccessExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.ElementAccess +elementAccessWithArguments :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.ElementAccess +elementAccessWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ElementAccess +elementAccessWithExpression :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ElementAccess +elementAccessWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ElementInitializer +elementInitializerElementInitializer :: Typed.TypedName Syntax.ElementInitializer +elementInitializerElementInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ElementInitializer") + +-- | DSL injection for the list variant of hydra.ext.csharp.syntax.ElementInitializer +elementInitializerList :: Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm Syntax.ElementInitializer +elementInitializerList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the single variant of hydra.ext.csharp.syntax.ElementInitializer +elementInitializerSingle :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.ElementInitializer +elementInitializerSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the checked variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementChecked :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementChecked x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "checked"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementEmbeddedStatement :: Typed.TypedName Syntax.EmbeddedStatement +embeddedStatementEmbeddedStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement") + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementEmpty :: Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementExpression :: Typed.TypedTerm Syntax.StatementExpression -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the fixed variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementFixed :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementFixed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the iteration variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementIteration :: Typed.TypedTerm Syntax.IterationStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementIteration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "iteration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the jump variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementJump :: Typed.TypedTerm Syntax.JumpStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementJump x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "jump"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lock variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementLock :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementLock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lock"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the selection variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementSelection :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementSelection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "selection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the try variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementTry :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementTry x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "try"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unchecked variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementUnchecked :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementUnchecked x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unchecked"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementUnsafe :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementUnsafe x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the using variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementUsing :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementUsing x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "using"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the yield variant of hydra.ext.csharp.syntax.EmbeddedStatement +embeddedStatementYield :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +embeddedStatementYield x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "yield"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumBase +enumBaseEnumBase :: Typed.TypedName Syntax.EnumBase +enumBaseEnumBase = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumBase") + +-- | DSL injection for the name variant of hydra.ext.csharp.syntax.EnumBase +enumBaseName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.EnumBase +enumBaseName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.EnumBase +enumBaseType :: Typed.TypedTerm Syntax.IntegralType -> Typed.TypedTerm Syntax.EnumBase +enumBaseType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBase"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.EnumBody wrapper +enumBody :: Typed.TypedTerm [Syntax.EnumMemberDeclaration] -> Typed.TypedTerm Syntax.EnumBody +enumBody x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBody"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumBody +enumBodyEnumBody :: Typed.TypedName Syntax.EnumBody +enumBodyEnumBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.EnumDeclaration +enumDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EnumModifier] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.EnumBase) -> Typed.TypedTerm (Maybe Syntax.EnumBody) -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclaration attributes modifiers name base body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm base)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationAttributes :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +enumDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the base field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationBase :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBase) +enumDeclarationBase x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBody) +enumDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationEnumDeclaration :: Typed.TypedName Syntax.EnumDeclaration +enumDeclarationEnumDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration") + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.EnumModifier] +enumDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationName :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.Identifier +enumDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationWithAttributes :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the base field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationWithBase :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBase) -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclarationWithBase original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationWithBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBody) -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationWithModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.EnumModifier] -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.EnumDeclaration +enumDeclarationWithName :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.EnumDeclaration +enumDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.EnumMemberDeclaration +enumMemberDeclaration attributes name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationAttributes :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +enumMemberDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationEnumMemberDeclaration :: Typed.TypedName Syntax.EnumMemberDeclaration +enumMemberDeclarationEnumMemberDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationName :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm Syntax.Identifier +enumMemberDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the value field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationValue :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) +enumMemberDeclarationValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationWithAttributes :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.EnumMemberDeclaration +enumMemberDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationWithName :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.EnumMemberDeclaration +enumMemberDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.csharp.syntax.EnumMemberDeclaration +enumMemberDeclarationWithValue :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.EnumMemberDeclaration +enumMemberDeclarationWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumModifier +enumModifierEnumModifier :: Typed.TypedName Syntax.EnumModifier +enumModifierEnumModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.EnumModifier +enumModifierInternal :: Typed.TypedTerm Syntax.EnumModifier +enumModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.EnumModifier +enumModifierNew :: Typed.TypedTerm Syntax.EnumModifier +enumModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.EnumModifier +enumModifierPrivate :: Typed.TypedTerm Syntax.EnumModifier +enumModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.EnumModifier +enumModifierProtected :: Typed.TypedTerm Syntax.EnumModifier +enumModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.EnumModifier +enumModifierPublic :: Typed.TypedTerm Syntax.EnumModifier +enumModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.EnumType wrapper +enumType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.EnumType +enumType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.EnumType +enumTypeEnumType :: Typed.TypedName Syntax.EnumType +enumTypeEnumType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumType") + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.EqualityExpression +equalityExpressionBinary :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression +equalityExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EqualityExpression +equalityExpressionEqualityExpression :: Typed.TypedName Syntax.EqualityExpression +equalityExpressionEqualityExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EqualityExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.EqualityExpression +equalityExpressionSimple :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression +equalityExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the equal variant of hydra.ext.csharp.syntax.EqualityOperator +equalityOperatorEqual :: Typed.TypedTerm Syntax.EqualityOperator +equalityOperatorEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EqualityOperator +equalityOperatorEqualityOperator :: Typed.TypedName Syntax.EqualityOperator +equalityOperatorEqualityOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EqualityOperator") + +-- | DSL injection for the notEqual variant of hydra.ext.csharp.syntax.EqualityOperator +equalityOperatorNotEqual :: Typed.TypedTerm Syntax.EqualityOperator +equalityOperatorNotEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "notEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the add variant of hydra.ext.csharp.syntax.EventAccessorDeclarations +eventAccessorDeclarationsAdd :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations +eventAccessorDeclarationsAdd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "add"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EventAccessorDeclarations +eventAccessorDeclarationsEventAccessorDeclarations :: Typed.TypedName Syntax.EventAccessorDeclarations +eventAccessorDeclarationsEventAccessorDeclarations = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations") + +-- | DSL injection for the remove variant of hydra.ext.csharp.syntax.EventAccessorDeclarations +eventAccessorDeclarationsRemove :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations +eventAccessorDeclarationsRemove x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "remove"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the accessors variant of hydra.ext.csharp.syntax.EventDeclaration +eventDeclarationAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventDeclaration +eventDeclarationAccessors x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EventDeclaration +eventDeclarationEventDeclaration :: Typed.TypedName Syntax.EventDeclaration +eventDeclarationEventDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventDeclaration") + +-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.EventDeclaration +eventDeclarationStandard :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.EventDeclaration +eventDeclarationStandard x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "standard"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.EventModifier +eventModifierAbstract :: Typed.TypedTerm Syntax.EventModifier +eventModifierAbstract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "abstract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.EventModifier +eventModifierEventModifier :: Typed.TypedName Syntax.EventModifier +eventModifierEventModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventModifier") + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.EventModifier +eventModifierExtern :: Typed.TypedTerm Syntax.EventModifier +eventModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.EventModifier +eventModifierInternal :: Typed.TypedTerm Syntax.EventModifier +eventModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.EventModifier +eventModifierNew :: Typed.TypedTerm Syntax.EventModifier +eventModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the override variant of hydra.ext.csharp.syntax.EventModifier +eventModifierOverride :: Typed.TypedTerm Syntax.EventModifier +eventModifierOverride = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.EventModifier +eventModifierPrivate :: Typed.TypedTerm Syntax.EventModifier +eventModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.EventModifier +eventModifierProtected :: Typed.TypedTerm Syntax.EventModifier +eventModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.EventModifier +eventModifierPublic :: Typed.TypedTerm Syntax.EventModifier +eventModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.EventModifier +eventModifierSealed :: Typed.TypedTerm Syntax.EventModifier +eventModifierSealed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sealed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.EventModifier +eventModifierStatic :: Typed.TypedTerm Syntax.EventModifier +eventModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.EventModifier +eventModifierUnsafe :: Typed.TypedTerm Syntax.EventModifier +eventModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.EventModifier +eventModifierVirtual :: Typed.TypedTerm Syntax.EventModifier +eventModifierVirtual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "virtual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifier :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ExceptionSpecifier +exceptionSpecifier type_ identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifierExceptionSpecifier :: Typed.TypedName Syntax.ExceptionSpecifier +exceptionSpecifierExceptionSpecifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifierIdentifier :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm (Maybe Syntax.Identifier) +exceptionSpecifierIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifierType :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm Syntax.Type +exceptionSpecifierType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifierWithIdentifier :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ExceptionSpecifier +exceptionSpecifierWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExceptionSpecifier +exceptionSpecifierWithType :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExceptionSpecifier +exceptionSpecifierWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ExclusiveOrExpression +exclusiveOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression +exclusiveOrExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExclusiveOrExpression +exclusiveOrExpressionExclusiveOrExpression :: Typed.TypedName Syntax.ExclusiveOrExpression +exclusiveOrExpressionExclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ExclusiveOrExpression +exclusiveOrExpressionSimple :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression +exclusiveOrExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameter :: Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameter modifier type_ identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm modifier)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterExplicitAnonymousFunctionParameter :: Typed.TypedName Syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterExplicitAnonymousFunctionParameter = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterIdentifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Identifier +explicitAnonymousFunctionParameterIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterModifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier) +explicitAnonymousFunctionParameterModifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterType :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Type +explicitAnonymousFunctionParameterType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithIdentifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithModifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithModifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithType :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter +explicitAnonymousFunctionParameterWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclaration :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclaration type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationDeclarators :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] +explicitlyTypedLocalVariableDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationExplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationExplicitlyTypedLocalVariableDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationType :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type +explicitlyTypedLocalVariableDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationWithDeclarators :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationWithType :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration +explicitlyTypedLocalVariableDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer) -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclarator identifier initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorExplicitlyTypedLocalVariableDeclarator :: Typed.TypedName Syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorExplicitlyTypedLocalVariableDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorIdentifier :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier +explicitlyTypedLocalVariableDeclaratorIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorInitializer :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer) +explicitlyTypedLocalVariableDeclaratorInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorWithInitializer :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer) -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator +explicitlyTypedLocalVariableDeclaratorWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.Expression +expressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression +expressionAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.Expression +expressionExpression :: Typed.TypedName Syntax.Expression +expressionExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Expression") + +-- | DSL constructor for the hydra.ext.csharp.syntax.ExpressionList wrapper +expressionList :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ExpressionList +expressionList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ExpressionList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExpressionList +expressionListExpressionList :: Typed.TypedName Syntax.ExpressionList +expressionListExpressionList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExpressionList") + +-- | DSL injection for the nonAssignment variant of hydra.ext.csharp.syntax.Expression +expressionNonAssignment :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.Expression +expressionNonAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nonAssignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.ExternAliasDirective wrapper +externAliasDirective :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExternAliasDirective +externAliasDirective x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ExternAliasDirective +externAliasDirectiveExternAliasDirective :: Typed.TypedName Syntax.ExternAliasDirective +externAliasDirectiveExternAliasDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective") + +-- | DSL constructor for hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration +fieldDeclaration attributes modifiers type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationAttributes :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +fieldDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] +fieldDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationFieldDeclaration :: Typed.TypedName Syntax.FieldDeclaration +fieldDeclarationFieldDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration") + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier] +fieldDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.Type +fieldDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationWithAttributes :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FieldDeclaration +fieldDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationWithDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration +fieldDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationWithModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.FieldDeclaration +fieldDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.FieldDeclaration +fieldDeclarationWithType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FieldDeclaration +fieldDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.FieldModifier +fieldModifierFieldModifier :: Typed.TypedName Syntax.FieldModifier +fieldModifierFieldModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FieldModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierInternal :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierNew :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierPrivate :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierProtected :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierPublic :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the readonly variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierReadonly :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierReadonly = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "readonly"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierStatic :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierUnsafe :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the volatile variant of hydra.ext.csharp.syntax.FieldModifier +fieldModifierVolatile :: Typed.TypedTerm Syntax.FieldModifier +fieldModifierVolatile = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "volatile"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.FinalizerBody +finalizerBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FinalizerBody +finalizerBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.FinalizerBody +finalizerBodyEmpty :: Typed.TypedTerm Syntax.FinalizerBody +finalizerBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.FinalizerBody +finalizerBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FinalizerBody +finalizerBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.FinalizerBody +finalizerBodyFinalizerBody :: Typed.TypedName Syntax.FinalizerBody +finalizerBodyFinalizerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FinalizerBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FinalizerBody -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclaration attributes extern unsafe name body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Typed.unTypedTerm extern)}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Typed.unTypedTerm unsafe)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationAttributes :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +finalizerDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationBody :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.FinalizerBody +finalizerDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the extern field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationExtern :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool +finalizerDeclarationExtern x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationFinalizerDeclaration :: Typed.TypedName Syntax.FinalizerDeclaration +finalizerDeclarationFinalizerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationName :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.Identifier +finalizerDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the unsafe field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationUnsafe :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool +finalizerDeclarationUnsafe x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationWithAttributes :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationWithBody :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.FinalizerBody -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the extern field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationWithExtern :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclarationWithExtern original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationWithName :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unsafe field of hydra.ext.csharp.syntax.FinalizerDeclaration +finalizerDeclarationWithUnsafe :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.FinalizerDeclaration +finalizerDeclarationWithUnsafe original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FixedParameter +fixedParameter :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.ParameterModifier) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FixedParameter +fixedParameter attributes modifier type_ identifier defaultArgument = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm modifier)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Typed.unTypedTerm defaultArgument)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterAttributes :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) +fixedParameterAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the defaultArgument field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterDefaultArgument :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Expression) +fixedParameterDefaultArgument x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "defaultArgument")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedParameter +fixedParameterFixedParameter :: Typed.TypedName Syntax.FixedParameter +fixedParameterFixedParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedParameter") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterIdentifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Identifier +fixedParameterIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterModifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.ParameterModifier) +fixedParameterModifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterType :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Type +fixedParameterType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterWithAttributes :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FixedParameter +fixedParameterWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "defaultArgument")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the defaultArgument field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterWithDefaultArgument :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FixedParameter +fixedParameterWithDefaultArgument original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterWithIdentifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FixedParameter +fixedParameterWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "defaultArgument")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterWithModifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.ParameterModifier) -> Typed.TypedTerm Syntax.FixedParameter +fixedParameterWithModifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "defaultArgument")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.FixedParameter +fixedParameterWithType :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedParameter +fixedParameterWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultArgument"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"), + Model.projectionFieldName = (Model.Name "defaultArgument")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.FixedPointerDeclarator +fixedPointerDeclaratorExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FixedPointerDeclarator +fixedPointerDeclaratorExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedPointerDeclarator +fixedPointerDeclaratorFixedPointerDeclarator :: Typed.TypedName Syntax.FixedPointerDeclarator +fixedPointerDeclaratorFixedPointerDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator") + +-- | DSL injection for the reference variant of hydra.ext.csharp.syntax.FixedPointerDeclarator +fixedPointerDeclaratorReference :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.FixedPointerDeclarator +fixedPointerDeclaratorReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclaration attributes modifiers elementType declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationAttributes :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +fixedSizeBufferDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationDeclarators :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator] +fixedSizeBufferDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elementType field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationElementType :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.Type +fixedSizeBufferDeclarationElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationFixedSizeBufferDeclaration :: Typed.TypedName Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationFixedSizeBufferDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration") + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationModifiers :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier] +fixedSizeBufferDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithAttributes :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithDeclarators :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the elementType field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithElementType :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithModifiers :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration +fixedSizeBufferDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclarator name size = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "size"), + Model.fieldTerm = (Typed.unTypedTerm size)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorFixedSizeBufferDeclarator :: Typed.TypedName Syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorFixedSizeBufferDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorName :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.Identifier +fixedSizeBufferDeclaratorName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the size field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorSize :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.ConstantExpression +fixedSizeBufferDeclaratorSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.projectionFieldName = (Model.Name "size")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorWithName :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "size"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.projectionFieldName = (Model.Name "size")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the size field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorWithSize :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator +fixedSizeBufferDeclaratorWithSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "size"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierFixedSizeBufferModifier :: Typed.TypedName Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierFixedSizeBufferModifier = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierInternal :: Typed.TypedTerm Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierNew :: Typed.TypedTerm Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierPrivate :: Typed.TypedTerm Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierPublic :: Typed.TypedTerm Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier +fixedSizeBufferModifierUnsafe :: Typed.TypedTerm Syntax.FixedSizeBufferModifier +fixedSizeBufferModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FixedStatement +fixedStatement :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm [Syntax.FixedPointerDeclarator] -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.FixedStatement +fixedStatement pointerType declarators statement = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointerType"), + Model.fieldTerm = (Typed.unTypedTerm pointerType)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm statement)}]})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementDeclarators :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm [Syntax.FixedPointerDeclarator] +fixedStatementDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FixedStatement +fixedStatementFixedStatement :: Typed.TypedName Syntax.FixedStatement +fixedStatementFixedStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedStatement") + +-- | DSL accessor for the pointerType field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementPointerType :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.PointerType +fixedStatementPointerType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "pointerType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the statement field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementStatement :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +fixedStatementStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementWithDeclarators :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm [Syntax.FixedPointerDeclarator] -> Typed.TypedTerm Syntax.FixedStatement +fixedStatementWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointerType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "pointerType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pointerType field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementWithPointerType :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.FixedStatement +fixedStatementWithPointerType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointerType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statement field of hydra.ext.csharp.syntax.FixedStatement +fixedStatementWithStatement :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.FixedStatement +fixedStatementWithStatement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointerType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "pointerType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the double variant of hydra.ext.csharp.syntax.FloatingPointType +floatingPointTypeDouble :: Typed.TypedTerm Syntax.FloatingPointType +floatingPointTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FloatingPointType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.csharp.syntax.FloatingPointType +floatingPointTypeFloat :: Typed.TypedTerm Syntax.FloatingPointType +floatingPointTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FloatingPointType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.FloatingPointType +floatingPointTypeFloatingPointType :: Typed.TypedName Syntax.FloatingPointType +floatingPointTypeFloatingPointType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FloatingPointType") + +-- | DSL name token for hydra.ext.csharp.syntax.ForInitializer +forInitializerForInitializer :: Typed.TypedName Syntax.ForInitializer +forInitializerForInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForInitializer") + +-- | DSL injection for the statements variant of hydra.ext.csharp.syntax.ForInitializer +forInitializerStatements :: Typed.TypedTerm Syntax.StatementExpressionList -> Typed.TypedTerm Syntax.ForInitializer +forInitializerStatements x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "statements"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the variable variant of hydra.ext.csharp.syntax.ForInitializer +forInitializerVariable :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.ForInitializer +forInitializerVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ForStatement +forStatement :: Typed.TypedTerm (Maybe Syntax.ForInitializer) -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList) -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForStatement +forStatement initializer condition iterator body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "iterator"), + Model.fieldTerm = (Typed.unTypedTerm iterator)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ForStatement +forStatementBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +forStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.ForStatement +forStatementCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) +forStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ForStatement +forStatementForStatement :: Typed.TypedName Syntax.ForStatement +forStatementForStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForStatement") + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ForStatement +forStatementInitializer :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.ForInitializer) +forStatementInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the iterator field of hydra.ext.csharp.syntax.ForStatement +forStatementIterator :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList) +forStatementIterator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "iterator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.ForStatement +forStatementWithBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForStatement +forStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "iterator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "iterator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the condition field of hydra.ext.csharp.syntax.ForStatement +forStatementWithCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.ForStatement +forStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "iterator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "iterator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ForStatement +forStatementWithInitializer :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.ForInitializer) -> Typed.TypedTerm Syntax.ForStatement +forStatementWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "iterator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "iterator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the iterator field of hydra.ext.csharp.syntax.ForStatement +forStatementWithIterator :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList) -> Typed.TypedTerm Syntax.ForStatement +forStatementWithIterator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "iterator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ForeachStatement +foreachStatement :: Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatement kind type_ identifier expression body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementBody :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +foreachStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementExpression :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Expression +foreachStatementExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ForeachStatement +foreachStatementForeachStatement :: Typed.TypedName Syntax.ForeachStatement +foreachStatementForeachStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForeachStatement") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementIdentifier :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Identifier +foreachStatementIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementKind :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm (Maybe Syntax.RefKind) +foreachStatementKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementType :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.LocalVariableType +foreachStatementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementWithBody :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementWithExpression :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatementWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementWithIdentifier :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatementWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the kind field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementWithKind :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatementWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ForeachStatement +foreachStatementWithType :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.ForeachStatement +foreachStatementWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FormalParameterList +formalParameterList :: Typed.TypedTerm [Syntax.FixedParameter] -> Typed.TypedTerm (Maybe Syntax.ParameterArray) -> Typed.TypedTerm Syntax.FormalParameterList +formalParameterList fixed array = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm fixed)}, + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm array)}]})) + +-- | DSL accessor for the array field of hydra.ext.csharp.syntax.FormalParameterList +formalParameterListArray :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm (Maybe Syntax.ParameterArray) +formalParameterListArray x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.projectionFieldName = (Model.Name "array")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the fixed field of hydra.ext.csharp.syntax.FormalParameterList +formalParameterListFixed :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.FixedParameter] +formalParameterListFixed x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.projectionFieldName = (Model.Name "fixed")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.FormalParameterList +formalParameterListFormalParameterList :: Typed.TypedName Syntax.FormalParameterList +formalParameterListFormalParameterList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FormalParameterList") + +-- | DSL updater for the array field of hydra.ext.csharp.syntax.FormalParameterList +formalParameterListWithArray :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm (Maybe Syntax.ParameterArray) -> Typed.TypedTerm Syntax.FormalParameterList +formalParameterListWithArray original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.projectionFieldName = (Model.Name "fixed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the fixed field of hydra.ext.csharp.syntax.FormalParameterList +formalParameterListWithFixed :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.FixedParameter] -> Typed.TypedTerm Syntax.FormalParameterList +formalParameterListWithFixed original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"), + Model.projectionFieldName = (Model.Name "array")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.FromClause +fromClause :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FromClause +fromClause type_ identifier in_ = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Typed.unTypedTerm in_)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.FromClause +fromClauseFromClause :: Typed.TypedName Syntax.FromClause +fromClauseFromClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FromClause") + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.FromClause +fromClauseIdentifier :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Identifier +fromClauseIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the in field of hydra.ext.csharp.syntax.FromClause +fromClauseIn :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Expression +fromClauseIn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FromClause +fromClauseType :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm (Maybe Syntax.Type) +fromClauseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.FromClause +fromClauseWithIdentifier :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FromClause +fromClauseWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the in field of hydra.ext.csharp.syntax.FromClause +fromClauseWithIn :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FromClause +fromClauseWithIn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.FromClause +fromClauseWithType :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.FromClause +fromClauseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSection :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.GlobalAttributeSection +globalAttributeSection target attributes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSectionAttributes :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.AttributeList +globalAttributeSectionAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSectionGlobalAttributeSection :: Typed.TypedName Syntax.GlobalAttributeSection +globalAttributeSectionGlobalAttributeSection = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection") + +-- | DSL accessor for the target field of hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSectionTarget :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.Identifier +globalAttributeSectionTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSectionWithAttributes :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.GlobalAttributeSection +globalAttributeSectionWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the target field of hydra.ext.csharp.syntax.GlobalAttributeSection +globalAttributeSectionWithTarget :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.GlobalAttributeSection +globalAttributeSectionWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the case variant of hydra.ext.csharp.syntax.GotoStatement +gotoStatementCase :: Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.GotoStatement +gotoStatementCase x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "case"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the default variant of hydra.ext.csharp.syntax.GotoStatement +gotoStatementDefault :: Typed.TypedTerm Syntax.GotoStatement +gotoStatementDefault = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.GotoStatement +gotoStatementGotoStatement :: Typed.TypedName Syntax.GotoStatement +gotoStatementGotoStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GotoStatement") + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.GotoStatement +gotoStatementIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.GotoStatement +gotoStatementIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.GroupClause +groupClause :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause +groupClause grouped by = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "grouped"), + Model.fieldTerm = (Typed.unTypedTerm grouped)}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Typed.unTypedTerm by)}]})) + +-- | DSL accessor for the by field of hydra.ext.csharp.syntax.GroupClause +groupClauseBy :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression +groupClauseBy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.projectionFieldName = (Model.Name "by")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.GroupClause +groupClauseGroupClause :: Typed.TypedName Syntax.GroupClause +groupClauseGroupClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GroupClause") + +-- | DSL accessor for the grouped field of hydra.ext.csharp.syntax.GroupClause +groupClauseGrouped :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression +groupClauseGrouped x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.projectionFieldName = (Model.Name "grouped")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the by field of hydra.ext.csharp.syntax.GroupClause +groupClauseWithBy :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause +groupClauseWithBy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "grouped"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.projectionFieldName = (Model.Name "grouped")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the grouped field of hydra.ext.csharp.syntax.GroupClause +groupClauseWithGrouped :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause +groupClauseWithGrouped original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "grouped"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"), + Model.projectionFieldName = (Model.Name "by")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.Identifier wrapper +identifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Identifier +identifier x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Identifier"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Identifier +identifierIdentifier :: Typed.TypedName Syntax.Identifier +identifierIdentifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Identifier") + +-- | DSL constructor for hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeName identifier arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameArguments :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +identifierNamespaceOrTypeNameArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier +identifierNamespaceOrTypeNameIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameIdentifierNamespaceOrTypeName :: Typed.TypedName Syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameIdentifierNamespaceOrTypeName = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName") + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameWithArguments :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameWithIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName +identifierNamespaceOrTypeNameWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.IfStatement +ifStatement :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement +ifStatement condition ifBranch elseBranch = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "ifBranch"), + Model.fieldTerm = (Typed.unTypedTerm ifBranch)}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Typed.unTypedTerm elseBranch)}]})) + +-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.IfStatement +ifStatementCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.BooleanExpression +ifStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elseBranch field of hydra.ext.csharp.syntax.IfStatement +ifStatementElseBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +ifStatementElseBranch x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ifBranch field of hydra.ext.csharp.syntax.IfStatement +ifStatementIfBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +ifStatementIfBranch x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "ifBranch")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.IfStatement +ifStatementIfStatement :: Typed.TypedName Syntax.IfStatement +ifStatementIfStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IfStatement") + +-- | DSL updater for the condition field of hydra.ext.csharp.syntax.IfStatement +ifStatementWithCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.IfStatement +ifStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ifBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "ifBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the elseBranch field of hydra.ext.csharp.syntax.IfStatement +ifStatementWithElseBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement +ifStatementWithElseBranch original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ifBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "ifBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ifBranch field of hydra.ext.csharp.syntax.IfStatement +ifStatementWithIfBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement +ifStatementWithIfBranch original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ifBranch"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elseBranch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"), + Model.projectionFieldName = (Model.Name "elseBranch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationImplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationImplicitlyTypedLocalVariableDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration") + +-- | DSL injection for the refVar variant of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationRefVar :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationRefVar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "refVar"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the var variant of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationVar :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration +implicitlyTypedLocalVariableDeclarationVar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "var"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclarator identifier expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorExpression :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Expression +implicitlyTypedLocalVariableDeclaratorExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorIdentifier :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier +implicitlyTypedLocalVariableDeclaratorIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorImplicitlyTypedLocalVariableDeclarator :: Typed.TypedName Syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorImplicitlyTypedLocalVariableDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator") + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorWithExpression :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator +implicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.InclusiveOrExpression +inclusiveOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression +inclusiveOrExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.InclusiveOrExpression +inclusiveOrExpressionInclusiveOrExpression :: Typed.TypedName Syntax.InclusiveOrExpression +inclusiveOrExpressionInclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.InclusiveOrExpression +inclusiveOrExpressionSimple :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression +inclusiveOrExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.IndexerBody +indexerBodyBlock :: Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm Syntax.IndexerBody +indexerBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.IndexerBody +indexerBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IndexerBody +indexerBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.IndexerBody +indexerBodyIndexerBody :: Typed.TypedName Syntax.IndexerBody +indexerBodyIndexerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerBody") + +-- | DSL name token for hydra.ext.csharp.syntax.IndexerDeclaration +indexerDeclarationIndexerDeclaration :: Typed.TypedName Syntax.IndexerDeclaration +indexerDeclarationIndexerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.IndexerDeclaration +indexerDeclarationRef :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclaration +indexerDeclarationRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.IndexerDeclaration +indexerDeclarationStandard :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclaration +indexerDeclarationStandard x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "standard"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.InterfaceType) -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.IndexerDeclarator +indexerDeclarator type_ interface parameters = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm interface)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorIndexerDeclarator :: Typed.TypedName Syntax.IndexerDeclarator +indexerDeclaratorIndexerDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator") + +-- | DSL accessor for the interface field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorInterface :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm (Maybe Syntax.InterfaceType) +indexerDeclaratorInterface x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "interface")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorParameters :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.FormalParameterList +indexerDeclaratorParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorType :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.Type +indexerDeclaratorType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the interface field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorWithInterface :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm (Maybe Syntax.InterfaceType) -> Typed.TypedTerm Syntax.IndexerDeclarator +indexerDeclaratorWithInterface original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorWithParameters :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.IndexerDeclarator +indexerDeclaratorWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "interface")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.IndexerDeclarator +indexerDeclaratorWithType :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IndexerDeclarator +indexerDeclaratorWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "interface")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierAbstract :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierAbstract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "abstract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierExtern :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.IndexerModifier +indexerModifierIndexerModifier :: Typed.TypedName Syntax.IndexerModifier +indexerModifierIndexerModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierInternal :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierNew :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the override variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierOverride :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierOverride = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierPrivate :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierProtected :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierPublic :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierSealed :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierSealed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sealed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierUnsafe :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.IndexerModifier +indexerModifierVirtual :: Typed.TypedTerm Syntax.IndexerModifier +indexerModifierVirtual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "virtual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the arguments variant of hydra.ext.csharp.syntax.InitializerTarget +initializerTargetArguments :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.InitializerTarget +initializerTargetArguments x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.InitializerTarget +initializerTargetIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InitializerTarget +initializerTargetIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.InitializerTarget +initializerTargetInitializerTarget :: Typed.TypedName Syntax.InitializerTarget +initializerTargetInitializerTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InitializerTarget") + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.InitializerValue +initializerValueExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.InitializerValue +initializerValueExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.InitializerValue +initializerValueInitializerValue :: Typed.TypedName Syntax.InitializerValue +initializerValueInitializerValue = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InitializerValue") + +-- | DSL injection for the objectOrCollection variant of hydra.ext.csharp.syntax.InitializerValue +initializerValueObjectOrCollection :: Typed.TypedTerm Syntax.ObjectOrCollectionInitializer -> Typed.TypedTerm Syntax.InitializerValue +initializerValueObjectOrCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "objectOrCollection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.IntegerLiteral +integerLiteralBinary :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.IntegerLiteral +integerLiteralDecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralDecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the hexadecimal variant of hydra.ext.csharp.syntax.IntegerLiteral +integerLiteralHexadecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral +integerLiteralHexadecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hexadecimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.IntegerLiteral +integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral +integerLiteralIntegerLiteral = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral") + +-- | DSL injection for the byte variant of hydra.ext.csharp.syntax.IntegralType +integralTypeByte :: Typed.TypedTerm Syntax.IntegralType +integralTypeByte = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byte"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the char variant of hydra.ext.csharp.syntax.IntegralType +integralTypeChar :: Typed.TypedTerm Syntax.IntegralType +integralTypeChar = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "char"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int variant of hydra.ext.csharp.syntax.IntegralType +integralTypeInt :: Typed.TypedTerm Syntax.IntegralType +integralTypeInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.IntegralType +integralTypeIntegralType :: Typed.TypedName Syntax.IntegralType +integralTypeIntegralType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IntegralType") + +-- | DSL injection for the long variant of hydra.ext.csharp.syntax.IntegralType +integralTypeLong :: Typed.TypedTerm Syntax.IntegralType +integralTypeLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sbyte variant of hydra.ext.csharp.syntax.IntegralType +integralTypeSbyte :: Typed.TypedTerm Syntax.IntegralType +integralTypeSbyte = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sbyte"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the short variant of hydra.ext.csharp.syntax.IntegralType +integralTypeShort :: Typed.TypedTerm Syntax.IntegralType +integralTypeShort = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "short"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uint variant of hydra.ext.csharp.syntax.IntegralType +integralTypeUint :: Typed.TypedTerm Syntax.IntegralType +integralTypeUint = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uint"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ulong variant of hydra.ext.csharp.syntax.IntegralType +integralTypeUlong :: Typed.TypedTerm Syntax.IntegralType +integralTypeUlong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ulong"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ushort variant of hydra.ext.csharp.syntax.IntegralType +integralTypeUshort :: Typed.TypedTerm Syntax.IntegralType +integralTypeUshort = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ushort"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessors :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors +interfaceAccessors attributes get set = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "get"), + Model.fieldTerm = (Typed.unTypedTerm get)}, + Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Typed.unTypedTerm set)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsAttributes :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceAccessorsAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the get field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsGet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceAccessorsGet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "get")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsInterfaceAccessors :: Typed.TypedName Syntax.InterfaceAccessors +interfaceAccessorsInterfaceAccessors = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors") + +-- | DSL accessor for the set field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsSet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceAccessorsSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "set")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsWithAttributes :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors +interfaceAccessorsWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "get"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "get")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "set")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the get field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsWithGet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors +interfaceAccessorsWithGet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "get"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "set")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the set field of hydra.ext.csharp.syntax.InterfaceAccessors +interfaceAccessorsWithSet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors +interfaceAccessorsWithSet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "get"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"), + Model.projectionFieldName = (Model.Name "get")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "set"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration] -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclaration attributes modifiers partial name parameters base constraints body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm partial)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm base)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the base field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationBase :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] +interfaceDeclarationBase x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationBody :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration] +interfaceDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationConstraints :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +interfaceDeclarationConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationInterfaceDeclaration :: Typed.TypedName Syntax.InterfaceDeclaration +interfaceDeclarationInterfaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration") + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationModifiers :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier] +interfaceDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationName :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.Identifier +interfaceDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationParameters :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) +interfaceDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationPartial :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Bool +interfaceDeclarationPartial x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the base field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithBase :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithBase original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithBody :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration] -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithConstraints :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithModifiers :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithName :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithParameters :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the partial field of hydra.ext.csharp.syntax.InterfaceDeclaration +interfaceDeclarationWithPartial :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceDeclaration +interfaceDeclarationWithPartial original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "base")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceEventDeclaration +interfaceEventDeclaration attributes new type_ name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm new)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceEventDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationInterfaceEventDeclaration :: Typed.TypedName Syntax.InterfaceEventDeclaration +interfaceEventDeclarationInterfaceEventDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationName :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Identifier +interfaceEventDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationNew :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Bool +interfaceEventDeclarationNew x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationType :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Type +interfaceEventDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithName :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithNew original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithType :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfaceEventDeclaration +interfaceEventDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclaration attributes new refKind type_ parameters accessors = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm new)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm accessors)}]})) + +-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationAccessors :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors +interfaceIndexerDeclarationAccessors x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceIndexerDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationInterfaceIndexerDeclaration :: Typed.TypedName Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationInterfaceIndexerDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration") + +-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationNew :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Bool +interfaceIndexerDeclarationNew x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationParameters :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.FormalParameterList +interfaceIndexerDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationRefKind :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) +interfaceIndexerDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationType :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.Type +interfaceIndexerDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithAccessors :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithAccessors original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithNew original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithParameters :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithType :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration +interfaceIndexerDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the event variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationEvent :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationEvent x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "event"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationIndexer :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationIndexer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "indexer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationInterfaceMemberDeclaration :: Typed.TypedName Syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationInterfaceMemberDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration") + +-- | DSL injection for the method variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationMethod :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "method"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the property variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationProperty :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration +interfaceMemberDeclarationProperty x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclaration attributes new returnType refKind header = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm new)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfaceMethodDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationInterfaceMethodDeclaration :: Typed.TypedName Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationInterfaceMethodDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration") + +-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationNew :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Bool +interfaceMethodDeclarationNew x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationRefKind :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) +interfaceMethodDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationReturnType :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType +interfaceMethodDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithNew original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration +interfaceMethodDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodHeader name parameters typeParameters constraints = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm typeParameters)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}]})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderConstraints :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +interfaceMethodHeaderConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderInterfaceMethodHeader :: Typed.TypedName Syntax.InterfaceMethodHeader +interfaceMethodHeaderInterfaceMethodHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderName :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.Identifier +interfaceMethodHeaderName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) +interfaceMethodHeaderParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderTypeParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) +interfaceMethodHeaderTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderWithConstraints :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodHeaderWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderWithName :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodHeaderWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderWithParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodHeaderWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader +interfaceMethodHeaderWithTypeParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.InterfaceMethodHeader +interfaceMethodHeaderWithTypeParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierInterfaceModifier :: Typed.TypedName Syntax.InterfaceModifier +interfaceModifierInterfaceModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier") + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierInternal :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierNew :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierPrivate :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierProtected :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierPublic :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.InterfaceModifier +interfaceModifierUnsafe :: Typed.TypedTerm Syntax.InterfaceModifier +interfaceModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclaration attributes new refKind type_ name accessors = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm new)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm accessors)}]})) + +-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationAccessors :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors +interfacePropertyDeclarationAccessors x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationAttributes :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +interfacePropertyDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationInterfacePropertyDeclaration :: Typed.TypedName Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationInterfacePropertyDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationName :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Identifier +interfacePropertyDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationNew :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Bool +interfacePropertyDeclarationNew x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationRefKind :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) +interfacePropertyDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationType :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Type +interfacePropertyDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithAccessors :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithAccessors original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithName :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithNew :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithNew original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithType :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration +interfacePropertyDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "new")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "accessors"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"), + Model.projectionFieldName = (Model.Name "accessors")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.InterfaceType wrapper +interfaceType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.InterfaceType +interfaceType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterfaceType +interfaceTypeInterfaceType :: Typed.TypedName Syntax.InterfaceType +interfaceTypeInterfaceType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceType") + +-- | DSL constructor for the hydra.ext.csharp.syntax.InterpolatedRegularStringExpression wrapper +interpolatedRegularStringExpression :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.InterpolatedRegularStringExpression +interpolatedRegularStringExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedRegularStringExpression +interpolatedRegularStringExpressionInterpolatedRegularStringExpression :: Typed.TypedName Syntax.InterpolatedRegularStringExpression +interpolatedRegularStringExpressionInterpolatedRegularStringExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression") + +-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedStringExpression +interpolatedStringExpressionInterpolatedStringExpression :: Typed.TypedName Syntax.InterpolatedStringExpression +interpolatedStringExpressionInterpolatedStringExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression") + +-- | DSL injection for the regular variant of hydra.ext.csharp.syntax.InterpolatedStringExpression +interpolatedStringExpressionRegular :: Typed.TypedTerm Syntax.InterpolatedRegularStringExpression -> Typed.TypedTerm Syntax.InterpolatedStringExpression +interpolatedStringExpressionRegular x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "regular"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the verbatim variant of hydra.ext.csharp.syntax.InterpolatedStringExpression +interpolatedStringExpressionVerbatim :: Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression -> Typed.TypedTerm Syntax.InterpolatedStringExpression +interpolatedStringExpressionVerbatim x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "verbatim"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression wrapper +interpolatedVerbatimStringExpression :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression +interpolatedVerbatimStringExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression +interpolatedVerbatimStringExpressionInterpolatedVerbatimStringExpression :: Typed.TypedName Syntax.InterpolatedVerbatimStringExpression +interpolatedVerbatimStringExpressionInterpolatedVerbatimStringExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression") + +-- | DSL constructor for hydra.ext.csharp.syntax.InvocationExpression +invocationExpression :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.InvocationExpression +invocationExpression expression arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.InvocationExpression +invocationExpressionArguments :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) +invocationExpressionArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.InvocationExpression +invocationExpressionExpression :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryExpression +invocationExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.InvocationExpression +invocationExpressionInvocationExpression :: Typed.TypedName Syntax.InvocationExpression +invocationExpressionInvocationExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InvocationExpression") + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.InvocationExpression +invocationExpressionWithArguments :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.InvocationExpression +invocationExpressionWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.InvocationExpression +invocationExpressionWithExpression :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.InvocationExpression +invocationExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.IsPatternExpression +isPatternExpression expression pattern = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm pattern)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpressionExpression :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression +isPatternExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpressionIsPatternExpression :: Typed.TypedName Syntax.IsPatternExpression +isPatternExpressionIsPatternExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression") + +-- | DSL accessor for the pattern field of hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpressionPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.Pattern +isPatternExpressionPattern x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpressionWithExpression :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.IsPatternExpression +isPatternExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pattern field of hydra.ext.csharp.syntax.IsPatternExpression +isPatternExpressionWithPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.IsPatternExpression +isPatternExpressionWithPattern original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IsTypeExpression +isTypeExpression expression type_ = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpressionExpression :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression +isTypeExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpressionIsTypeExpression :: Typed.TypedName Syntax.IsTypeExpression +isTypeExpressionIsTypeExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpressionType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.Type +isTypeExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpressionWithExpression :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.IsTypeExpression +isTypeExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.IsTypeExpression +isTypeExpressionWithType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IsTypeExpression +isTypeExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the do variant of hydra.ext.csharp.syntax.IterationStatement +iterationStatementDo :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementDo x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "do"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the for variant of hydra.ext.csharp.syntax.IterationStatement +iterationStatementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementFor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "for"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the foreach variant of hydra.ext.csharp.syntax.IterationStatement +iterationStatementForeach :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementForeach x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "foreach"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.IterationStatement +iterationStatementIterationStatement :: Typed.TypedName Syntax.IterationStatement +iterationStatementIterationStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IterationStatement") + +-- | DSL injection for the while variant of hydra.ext.csharp.syntax.IterationStatement +iterationStatementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.IterationStatement +iterationStatementWhile x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "while"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.JoinClause +joinClause :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.JoinClause +joinClause type_ identifier in_ on equals into = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Typed.unTypedTerm in_)}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Typed.unTypedTerm on)}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Typed.unTypedTerm equals)}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Typed.unTypedTerm into)}]})) + +-- | DSL accessor for the equals field of hydra.ext.csharp.syntax.JoinClause +joinClauseEquals :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression +joinClauseEquals x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.JoinClause +joinClauseIdentifier :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Identifier +joinClauseIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the in field of hydra.ext.csharp.syntax.JoinClause +joinClauseIn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression +joinClauseIn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the into field of hydra.ext.csharp.syntax.JoinClause +joinClauseInto :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Identifier) +joinClauseInto x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.JoinClause +joinClauseJoinClause :: Typed.TypedName Syntax.JoinClause +joinClauseJoinClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.JoinClause") + +-- | DSL accessor for the on field of hydra.ext.csharp.syntax.JoinClause +joinClauseOn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression +joinClauseOn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.JoinClause +joinClauseType :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Type) +joinClauseType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the equals field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithEquals :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithEquals original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithIdentifier :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the in field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithIn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithIn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the into field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithInto :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithInto original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the on field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithOn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithOn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.JoinClause +joinClauseWithType :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.JoinClause +joinClauseWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "in")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "equals"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "equals")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the break variant of hydra.ext.csharp.syntax.JumpStatement +jumpStatementBreak :: Typed.TypedTerm Syntax.JumpStatement +jumpStatementBreak = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "break"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the continue variant of hydra.ext.csharp.syntax.JumpStatement +jumpStatementContinue :: Typed.TypedTerm Syntax.JumpStatement +jumpStatementContinue = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "continue"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the goto variant of hydra.ext.csharp.syntax.JumpStatement +jumpStatementGoto :: Typed.TypedTerm Syntax.GotoStatement -> Typed.TypedTerm Syntax.JumpStatement +jumpStatementGoto x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "goto"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.JumpStatement +jumpStatementJumpStatement :: Typed.TypedName Syntax.JumpStatement +jumpStatementJumpStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.JumpStatement") + +-- | DSL injection for the return variant of hydra.ext.csharp.syntax.JumpStatement +jumpStatementReturn :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm Syntax.JumpStatement +jumpStatementReturn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "return"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the throw variant of hydra.ext.csharp.syntax.JumpStatement +jumpStatementThrow :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.JumpStatement +jumpStatementThrow x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "throw"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.Keyword wrapper +keyword :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Keyword +keyword x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Keyword"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Keyword +keywordKeyword :: Typed.TypedName Syntax.Keyword +keywordKeyword = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Keyword") + +-- | DSL constructor for hydra.ext.csharp.syntax.LabeledStatement +labeledStatement :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatement label statement = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Typed.unTypedTerm label)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm statement)}]})) + +-- | DSL accessor for the label field of hydra.ext.csharp.syntax.LabeledStatement +labeledStatementLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier +labeledStatementLabel x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "label")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LabeledStatement +labeledStatementLabeledStatement :: Typed.TypedName Syntax.LabeledStatement +labeledStatementLabeledStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LabeledStatement") + +-- | DSL accessor for the statement field of hydra.ext.csharp.syntax.LabeledStatement +labeledStatementStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement +labeledStatementStatement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the label field of hydra.ext.csharp.syntax.LabeledStatement +labeledStatementWithLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatementWithLabel original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "statement")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statement field of hydra.ext.csharp.syntax.LabeledStatement +labeledStatementWithStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement +labeledStatementWithStatement original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "label"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"), + Model.projectionFieldName = (Model.Name "label")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statement"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.LambdaExpression +lambdaExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AnonymousFunctionSignature -> Typed.TypedTerm Syntax.AnonymousFunctionBody -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpression async signature body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Typed.unTypedTerm async)}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Typed.unTypedTerm signature)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the async field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionAsync :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Bool +lambdaExpressionAsync x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody +lambdaExpressionBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression +lambdaExpressionLambdaExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LambdaExpression") + +-- | DSL accessor for the signature field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionSignature :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionSignature +lambdaExpressionSignature x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the async field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionWithAsync :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithAsync original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionWithBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "signature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the signature field of hydra.ext.csharp.syntax.LambdaExpression +lambdaExpressionWithSignature :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionSignature -> Typed.TypedTerm Syntax.LambdaExpression +lambdaExpressionWithSignature original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "async")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "signature"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.LetClause +letClause :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetClause +letClause left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.LetClause +letClauseLeft :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Identifier +letClauseLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LetClause +letClauseLetClause :: Typed.TypedName Syntax.LetClause +letClauseLetClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LetClause") + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.LetClause +letClauseRight :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Expression +letClauseRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.LetClause +letClauseWithLeft :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LetClause +letClauseWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.LetClause +letClauseWithRight :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetClause +letClauseWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the boolean variant of hydra.ext.csharp.syntax.Literal +literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Literal +literalBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the character variant of hydra.ext.csharp.syntax.Literal +literalCharacter :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal +literalCharacter x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "character"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the integer variant of hydra.ext.csharp.syntax.Literal +literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal +literalInteger x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.Literal +literalLiteral :: Typed.TypedName Syntax.Literal +literalLiteral = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Literal") + +-- | DSL injection for the null variant of hydra.ext.csharp.syntax.Literal +literalNull :: Typed.TypedTerm Syntax.Literal +literalNull = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the real variant of hydra.ext.csharp.syntax.Literal +literalReal :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Literal +literalReal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "real"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.csharp.syntax.Literal +literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal +literalString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclaration :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.LocalConstantDeclaration +localConstantDeclaration type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclarationDeclarators :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] +localConstantDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclarationLocalConstantDeclaration :: Typed.TypedName Syntax.LocalConstantDeclaration +localConstantDeclarationLocalConstantDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclarationType :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.Type +localConstantDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclarationWithDeclarators :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.LocalConstantDeclaration +localConstantDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.LocalConstantDeclaration +localConstantDeclarationWithType :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalConstantDeclaration +localConstantDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.LocalFunctionBody +localFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.LocalFunctionBody +localFunctionBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.LocalFunctionBody +localFunctionBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LocalFunctionBody +localFunctionBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionBody +localFunctionBodyLocalFunctionBody :: Typed.TypedName Syntax.LocalFunctionBody +localFunctionBodyLocalFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody") + +-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.LocalFunctionBody +localFunctionBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.LocalFunctionBody +localFunctionBodyNullConditionalInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalInvocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionDeclaration +localFunctionDeclarationLocalFunctionDeclaration :: Typed.TypedName Syntax.LocalFunctionDeclaration +localFunctionDeclarationLocalFunctionDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalFunctionDeclaration +localFunctionDeclarationRef :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionDeclaration +localFunctionDeclarationRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.LocalFunctionDeclaration +localFunctionDeclarationStandard :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionDeclaration +localFunctionDeclarationStandard x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "standard"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.LocalFunctionHeader +localFunctionHeader identifier typeParameters parameters constraints = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm typeParameters)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}]})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderConstraints :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +localFunctionHeaderConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderIdentifier :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.Identifier +localFunctionHeaderIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderLocalFunctionHeader :: Typed.TypedName Syntax.LocalFunctionHeader +localFunctionHeaderLocalFunctionHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader") + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.FormalParameterList +localFunctionHeaderParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderTypeParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) +localFunctionHeaderTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderWithConstraints :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.LocalFunctionHeader +localFunctionHeaderWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderWithIdentifier :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LocalFunctionHeader +localFunctionHeaderWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderWithParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.LocalFunctionHeader +localFunctionHeaderWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.LocalFunctionHeader +localFunctionHeaderWithTypeParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.LocalFunctionHeader +localFunctionHeaderWithTypeParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the async variant of hydra.ext.csharp.syntax.LocalFunctionModifier +localFunctionModifierAsync :: Typed.TypedTerm Syntax.LocalFunctionModifier +localFunctionModifierAsync = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionModifier +localFunctionModifierLocalFunctionModifier :: Typed.TypedName Syntax.LocalFunctionModifier +localFunctionModifierLocalFunctionModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalFunctionModifier +localFunctionModifierRef :: Typed.TypedTerm Syntax.RefLocalFunctionModifier -> Typed.TypedTerm Syntax.LocalFunctionModifier +localFunctionModifierRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the explicitlyTyped variant of hydra.ext.csharp.syntax.LocalVariableDeclaration +localVariableDeclarationExplicitlyTyped :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration +localVariableDeclarationExplicitlyTyped x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "explicitlyTyped"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the implicitlyTyped variant of hydra.ext.csharp.syntax.LocalVariableDeclaration +localVariableDeclarationImplicitlyTyped :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration +localVariableDeclarationImplicitlyTyped x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "implicitlyTyped"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableDeclaration +localVariableDeclarationLocalVariableDeclaration :: Typed.TypedName Syntax.LocalVariableDeclaration +localVariableDeclarationLocalVariableDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalVariableDeclaration +localVariableDeclarationRef :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration +localVariableDeclarationRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.LocalVariableInitializer +localVariableInitializerExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LocalVariableInitializer +localVariableInitializerExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the initializer variant of hydra.ext.csharp.syntax.LocalVariableInitializer +localVariableInitializerInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.LocalVariableInitializer +localVariableInitializerInitializer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableInitializer +localVariableInitializerLocalVariableInitializer :: Typed.TypedName Syntax.LocalVariableInitializer +localVariableInitializerLocalVariableInitializer = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer") + +-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableType +localVariableTypeLocalVariableType :: Typed.TypedName Syntax.LocalVariableType +localVariableTypeLocalVariableType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableType") + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.LocalVariableType +localVariableTypeType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalVariableType +localVariableTypeType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the var variant of hydra.ext.csharp.syntax.LocalVariableType +localVariableTypeVar :: Typed.TypedTerm Syntax.LocalVariableType +localVariableTypeVar = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "var"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.LockStatement +lockStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.LockStatement +lockStatement expression body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.LockStatement +lockStatementBody :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +lockStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.LockStatement +lockStatementExpression :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.Expression +lockStatementExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.LockStatement +lockStatementLockStatement :: Typed.TypedName Syntax.LockStatement +lockStatementLockStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LockStatement") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.LockStatement +lockStatementWithBody :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.LockStatement +lockStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.LockStatement +lockStatementWithExpression :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LockStatement +lockStatementWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.MemberAccess +memberAccess :: Typed.TypedTerm Syntax.MemberAccessHead -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.MemberAccess +memberAccess head identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Typed.unTypedTerm head)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL accessor for the head field of hydra.ext.csharp.syntax.MemberAccess +memberAccessHead :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberAccessHead +memberAccessHead x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "head")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberAccessHead +memberAccessHeadMemberAccessHead :: Typed.TypedName Syntax.MemberAccessHead +memberAccessHeadMemberAccessHead = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead") + +-- | DSL injection for the predefined variant of hydra.ext.csharp.syntax.MemberAccessHead +memberAccessHeadPredefined :: Typed.TypedTerm Syntax.PredefinedType -> Typed.TypedTerm Syntax.MemberAccessHead +memberAccessHeadPredefined x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predefined"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the primary variant of hydra.ext.csharp.syntax.MemberAccessHead +memberAccessHeadPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.MemberAccessHead +memberAccessHeadPrimary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the qualifiedAlias variant of hydra.ext.csharp.syntax.MemberAccessHead +memberAccessHeadQualifiedAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.MemberAccessHead +memberAccessHeadQualifiedAlias x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "qualifiedAlias"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.MemberAccess +memberAccessIdentifier :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.Identifier +memberAccessIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberAccess +memberAccessMemberAccess :: Typed.TypedName Syntax.MemberAccess +memberAccessMemberAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberAccess") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.MemberAccess +memberAccessTypeArguments :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +memberAccessTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the head field of hydra.ext.csharp.syntax.MemberAccess +memberAccessWithHead :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberAccessHead -> Typed.TypedTerm Syntax.MemberAccess +memberAccessWithHead original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.MemberAccess +memberAccessWithIdentifier :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberAccess +memberAccessWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "head")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.MemberAccess +memberAccessWithTypeArguments :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.MemberAccess +memberAccessWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "head")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorAssignment :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.MemberDeclarator +memberDeclaratorAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the baseAccess variant of hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorBaseAccess :: Typed.TypedTerm Syntax.BaseAccess -> Typed.TypedTerm Syntax.MemberDeclarator +memberDeclaratorBaseAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "baseAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.MemberDeclaratorList wrapper +memberDeclaratorList :: Typed.TypedTerm [Syntax.MemberDeclarator] -> Typed.TypedTerm Syntax.MemberDeclaratorList +memberDeclaratorList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberDeclaratorList +memberDeclaratorListMemberDeclaratorList :: Typed.TypedName Syntax.MemberDeclaratorList +memberDeclaratorListMemberDeclaratorList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList") + +-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorMemberAccess :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberDeclarator +memberDeclaratorMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "memberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorMemberDeclarator :: Typed.TypedName Syntax.MemberDeclarator +memberDeclaratorMemberDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator") + +-- | DSL injection for the name variant of hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.MemberDeclarator +memberDeclaratorName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nullConditionalProjectionInitializer variant of hydra.ext.csharp.syntax.MemberDeclarator +memberDeclaratorNullConditionalProjectionInitializer :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.MemberDeclarator +memberDeclaratorNullConditionalProjectionInitializer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalProjectionInitializer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.MemberInitializer +memberInitializer :: Typed.TypedTerm Syntax.InitializerTarget -> Typed.TypedTerm Syntax.InitializerValue -> Typed.TypedTerm Syntax.MemberInitializer +memberInitializer target value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberInitializer +memberInitializerMemberInitializer :: Typed.TypedName Syntax.MemberInitializer +memberInitializerMemberInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberInitializer") + +-- | DSL accessor for the target field of hydra.ext.csharp.syntax.MemberInitializer +memberInitializerTarget :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerTarget +memberInitializerTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the value field of hydra.ext.csharp.syntax.MemberInitializer +memberInitializerValue :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerValue +memberInitializerValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the target field of hydra.ext.csharp.syntax.MemberInitializer +memberInitializerWithTarget :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerTarget -> Typed.TypedTerm Syntax.MemberInitializer +memberInitializerWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.csharp.syntax.MemberInitializer +memberInitializerWithValue :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerValue -> Typed.TypedTerm Syntax.MemberInitializer +memberInitializerWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.MemberName +memberName :: Typed.TypedTerm (Maybe Syntax.TypeName) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberName +memberName interfaceType identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "interfaceType"), + Model.fieldTerm = (Typed.unTypedTerm interfaceType)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.MemberName +memberNameIdentifier :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.Identifier +memberNameIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the interfaceType field of hydra.ext.csharp.syntax.MemberName +memberNameInterfaceType :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeName) +memberNameInterfaceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.projectionFieldName = (Model.Name "interfaceType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.MemberName +memberNameMemberName :: Typed.TypedName Syntax.MemberName +memberNameMemberName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberName") + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.MemberName +memberNameWithIdentifier :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberName +memberNameWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "interfaceType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.projectionFieldName = (Model.Name "interfaceType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the interfaceType field of hydra.ext.csharp.syntax.MemberName +memberNameWithInterfaceType :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeName) -> Typed.TypedTerm Syntax.MemberName +memberNameWithInterfaceType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "interfaceType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.MethodBody +methodBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.MethodBody +methodBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.MethodBody +methodBodyEmpty :: Typed.TypedTerm Syntax.MethodBody +methodBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.MethodBody +methodBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MethodBody +methodBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MethodBody +methodBodyMethodBody :: Typed.TypedName Syntax.MethodBody +methodBodyMethodBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodBody") + +-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.MethodBody +methodBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.MethodBody +methodBodyNullConditionalInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalInvocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MethodDeclaration +methodDeclarationMethodDeclaration :: Typed.TypedName Syntax.MethodDeclaration +methodDeclarationMethodDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration") + +-- | DSL injection for the refReturn variant of hydra.ext.csharp.syntax.MethodDeclaration +methodDeclarationRefReturn :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodDeclaration +methodDeclarationRefReturn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "refReturn"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.MethodDeclaration +methodDeclarationStandard :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodDeclaration +methodDeclarationStandard x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "standard"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.MethodHeader +methodHeader :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.MethodHeader +methodHeader name typeParameters parameters constraints = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm typeParameters)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}]})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderConstraints :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +methodHeaderConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.MethodHeader +methodHeaderMethodHeader :: Typed.TypedName Syntax.MethodHeader +methodHeaderMethodHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodHeader") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderName :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MemberName +methodHeaderName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) +methodHeaderParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderTypeParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) +methodHeaderTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderWithConstraints :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.MethodHeader +methodHeaderWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderWithName :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.MethodHeader +methodHeaderWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderWithParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.MethodHeader +methodHeaderWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "typeParameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.MethodHeader +methodHeaderWithTypeParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.MethodHeader +methodHeaderWithTypeParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeParameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the async variant of hydra.ext.csharp.syntax.MethodModifier +methodModifierAsync :: Typed.TypedTerm Syntax.MethodModifier +methodModifierAsync = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "async"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MethodModifier +methodModifierMethodModifier :: Typed.TypedName Syntax.MethodModifier +methodModifierMethodModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodModifier") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.MethodModifier +methodModifierRef :: Typed.TypedTerm Syntax.RefMethodModifier -> Typed.TypedTerm Syntax.MethodModifier +methodModifierRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.MethodModifiers +methodModifiers :: Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodModifiers +methodModifiers modifiers partial = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm partial)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.MethodModifiers +methodModifiersMethodModifiers :: Typed.TypedName Syntax.MethodModifiers +methodModifiersMethodModifiers = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodModifiers") + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.MethodModifiers +methodModifiersModifiers :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm [Syntax.MethodModifier] +methodModifiersModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.MethodModifiers +methodModifiersPartial :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm Bool +methodModifiersPartial x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.MethodModifiers +methodModifiersWithModifiers :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.MethodModifiers +methodModifiersWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the partial field of hydra.ext.csharp.syntax.MethodModifiers +methodModifiersWithPartial :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodModifiers +methodModifiersWithPartial original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.MultiplicativeExpression +multiplicativeExpressionBinary :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MultiplicativeExpression +multiplicativeExpressionMultiplicativeExpression :: Typed.TypedName Syntax.MultiplicativeExpression +multiplicativeExpressionMultiplicativeExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.MultiplicativeExpression +multiplicativeExpressionSimple :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression +multiplicativeExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the divide variant of hydra.ext.csharp.syntax.MultiplicativeOperator +multiplicativeOperatorDivide :: Typed.TypedTerm Syntax.MultiplicativeOperator +multiplicativeOperatorDivide = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divide"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the modulo variant of hydra.ext.csharp.syntax.MultiplicativeOperator +multiplicativeOperatorModulo :: Typed.TypedTerm Syntax.MultiplicativeOperator +multiplicativeOperatorModulo = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modulo"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.MultiplicativeOperator +multiplicativeOperatorMultiplicativeOperator :: Typed.TypedName Syntax.MultiplicativeOperator +multiplicativeOperatorMultiplicativeOperator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator") + +-- | DSL injection for the times variant of hydra.ext.csharp.syntax.MultiplicativeOperator +multiplicativeOperatorTimes :: Typed.TypedTerm Syntax.MultiplicativeOperator +multiplicativeOperatorTimes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "times"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NamedArgument +namedArgument :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NamedArgument +namedArgument name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.NamedArgumentList wrapper +namedArgumentList :: Typed.TypedTerm [Syntax.NamedArgument] -> Typed.TypedTerm Syntax.NamedArgumentList +namedArgumentList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamedArgumentList +namedArgumentListNamedArgumentList :: Typed.TypedName Syntax.NamedArgumentList +namedArgumentListNamedArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.NamedArgument +namedArgumentName :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.Identifier +namedArgumentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamedArgument +namedArgumentNamedArgument :: Typed.TypedName Syntax.NamedArgument +namedArgumentNamedArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedArgument") + +-- | DSL accessor for the value field of hydra.ext.csharp.syntax.NamedArgument +namedArgumentValue :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression +namedArgumentValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.NamedArgument +namedArgumentWithName :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamedArgument +namedArgumentWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.csharp.syntax.NamedArgument +namedArgumentWithValue :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NamedArgument +namedArgumentWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NamedEntity +namedEntity :: Typed.TypedTerm Syntax.NamedEntityTarget -> Typed.TypedTerm [Syntax.NamedEntityPart] -> Typed.TypedTerm Syntax.NamedEntity +namedEntity target parts = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "parts"), + Model.fieldTerm = (Typed.unTypedTerm parts)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamedEntity +namedEntityNamedEntity :: Typed.TypedName Syntax.NamedEntity +namedEntityNamedEntity = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntity") + +-- | DSL constructor for hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPart :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NamedEntityPart +namedEntityPart identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPartIdentifier :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm Syntax.Identifier +namedEntityPartIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPartNamedEntityPart :: Typed.TypedName Syntax.NamedEntityPart +namedEntityPartNamedEntityPart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPartTypeArguments :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +namedEntityPartTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPartWithIdentifier :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamedEntityPart +namedEntityPartWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NamedEntityPart +namedEntityPartWithTypeArguments :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NamedEntityPart +namedEntityPartWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the parts field of hydra.ext.csharp.syntax.NamedEntity +namedEntityParts :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm [Syntax.NamedEntityPart] +namedEntityParts x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.projectionFieldName = (Model.Name "parts")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the target field of hydra.ext.csharp.syntax.NamedEntity +namedEntityTarget :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the base variant of hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetBase :: Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTargetBase = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the name variant of hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTargetName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetNamedEntityTarget :: Typed.TypedName Syntax.NamedEntityTarget +namedEntityTargetNamedEntityTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget") + +-- | DSL injection for the predefinedType variant of hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetPredefinedType :: Typed.TypedTerm Syntax.PredefinedType -> Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTargetPredefinedType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predefinedType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the qualifiedAliasMember variant of hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetQualifiedAliasMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTargetQualifiedAliasMember x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "qualifiedAliasMember"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the this variant of hydra.ext.csharp.syntax.NamedEntityTarget +namedEntityTargetThis :: Typed.TypedTerm Syntax.NamedEntityTarget +namedEntityTargetThis = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "this"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL updater for the parts field of hydra.ext.csharp.syntax.NamedEntity +namedEntityWithParts :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm [Syntax.NamedEntityPart] -> Typed.TypedTerm Syntax.NamedEntity +namedEntityWithParts original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parts"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the target field of hydra.ext.csharp.syntax.NamedEntity +namedEntityWithTarget :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.NamedEntityTarget -> Typed.TypedTerm Syntax.NamedEntity +namedEntityWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"), + Model.projectionFieldName = (Model.Name "parts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NamespaceBody +namespaceBody :: Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.NamespaceBody +namespaceBody externs usings members = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Typed.unTypedTerm externs)}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Typed.unTypedTerm usings)}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Typed.unTypedTerm members)}]})) + +-- | DSL accessor for the externs field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyExterns :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.ExternAliasDirective] +namespaceBodyExterns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the members field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyMembers :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] +namespaceBodyMembers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyNamespaceBody :: Typed.TypedName Syntax.NamespaceBody +namespaceBodyNamespaceBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceBody") + +-- | DSL accessor for the usings field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyUsings :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.UsingDirective] +namespaceBodyUsings x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the externs field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyWithExterns :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm Syntax.NamespaceBody +namespaceBodyWithExterns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the members field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyWithMembers :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.NamespaceBody +namespaceBodyWithMembers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "usings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the usings field of hydra.ext.csharp.syntax.NamespaceBody +namespaceBodyWithUsings :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm Syntax.NamespaceBody +namespaceBodyWithUsings original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "externs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "externs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "usings"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "members"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"), + Model.projectionFieldName = (Model.Name "members")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclaration :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclaration name body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclarationBody :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceBody +namespaceDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclarationName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.QualifiedIdentifier +namespaceDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclarationNamespaceDeclaration :: Typed.TypedName Syntax.NamespaceDeclaration +namespaceDeclarationNamespaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclarationWithBody :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.NamespaceDeclaration +namespaceDeclarationWithName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.NamespaceDeclaration +namespaceDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the namespace variant of hydra.ext.csharp.syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationNamespace :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationNamespace x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationNamespaceMemberDeclaration :: Typed.TypedName Syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationNamespaceMemberDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration") + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.NamespaceMemberDeclaration +namespaceMemberDeclarationType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.NamespaceName wrapper +namespaceName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceName +namespaceName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamespaceName +namespaceNameNamespaceName :: Typed.TypedName Syntax.NamespaceName +namespaceNameNamespaceName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceName") + +-- | DSL injection for the alias variant of hydra.ext.csharp.syntax.NamespaceOrTypeName +namespaceOrTypeNameAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.NamespaceOrTypeName +namespaceOrTypeNameAlias x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.NamespaceOrTypeName +namespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName +namespaceOrTypeNameIdentifier x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NamespaceOrTypeName +namespaceOrTypeNameNamespaceOrTypeName :: Typed.TypedName Syntax.NamespaceOrTypeName +namespaceOrTypeNameNamespaceOrTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName") + +-- | DSL injection for the qualified variant of hydra.ext.csharp.syntax.NamespaceOrTypeName +namespaceOrTypeNameQualified :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName +namespaceOrTypeNameQualified x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "qualified"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpression :: Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer) -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpression type_ expressions rankSpecifiers initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "expressions"), + Model.fieldTerm = (Typed.unTypedTerm expressions)}, + Model.Field { + Model.fieldName = (Model.Name "rankSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm rankSpecifiers)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the expressions field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionExpressions :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ExpressionList +nonArrayTypeArrayCreationExpressionExpressions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "expressions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer) +nonArrayTypeArrayCreationExpressionInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionNonArrayTypeArrayCreationExpression :: Typed.TypedName Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionNonArrayTypeArrayCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression") + +-- | DSL accessor for the rankSpecifiers field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionRankSpecifiers :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm [Syntax.RankSpecifier] +nonArrayTypeArrayCreationExpressionRankSpecifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeArrayCreationExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expressions field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithExpressions :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithExpressions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expressions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rankSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer) -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expressions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "expressions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rankSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the rankSpecifiers field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithRankSpecifiers :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithRankSpecifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expressions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "expressions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rankSpecifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression +nonArrayTypeArrayCreationExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expressions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "expressions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rankSpecifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the class variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeDelegate :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeDelegate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "delegate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the dynamic variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeDynamic :: Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeDynamic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dynamic"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeNonArrayType :: Typed.TypedName Syntax.NonArrayType +nonArrayTypeNonArrayType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonArrayType") + +-- | DSL injection for the parameter variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeParameter x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypePointer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the value variant of hydra.ext.csharp.syntax.NonArrayType +nonArrayTypeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.NonArrayType +nonArrayTypeValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the conditional variant of hydra.ext.csharp.syntax.NonAssignmentExpression +nonAssignmentExpressionConditional :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression +nonAssignmentExpressionConditional x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "conditional"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.NonAssignmentExpression +nonAssignmentExpressionDeclaration :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression +nonAssignmentExpressionDeclaration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lambda variant of hydra.ext.csharp.syntax.NonAssignmentExpression +nonAssignmentExpressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression +nonAssignmentExpressionLambda x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lambda"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NonAssignmentExpression +nonAssignmentExpressionNonAssignmentExpression :: Typed.TypedName Syntax.NonAssignmentExpression +nonAssignmentExpressionNonAssignmentExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression") + +-- | DSL injection for the query variant of hydra.ext.csharp.syntax.NonAssignmentExpression +nonAssignmentExpressionQuery :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression +nonAssignmentExpressionQuery x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "query"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.NullCoalescingExpression +nullCoalescingExpressionBinary :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +nullCoalescingExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NullCoalescingExpression +nullCoalescingExpressionNullCoalescingExpression :: Typed.TypedName Syntax.NullCoalescingExpression +nullCoalescingExpressionNullCoalescingExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.NullCoalescingExpression +nullCoalescingExpressionSimple :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +nullCoalescingExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the throw variant of hydra.ext.csharp.syntax.NullCoalescingExpression +nullCoalescingExpressionThrow :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +nullCoalescingExpressionThrow x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "throw"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalElementAccess +nullConditionalElementAccess expression arguments dependentAccess = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Typed.unTypedTerm dependentAccess)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessArguments :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.ArgumentList +nullConditionalElementAccessArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessDependentAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm [Syntax.DependentAccess] +nullConditionalElementAccessDependentAccess x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessExpression :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +nullConditionalElementAccessExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessNullConditionalElementAccess :: Typed.TypedName Syntax.NullConditionalElementAccess +nullConditionalElementAccessNullConditionalElementAccess = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess") + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessWithArguments :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.NullConditionalElementAccess +nullConditionalElementAccessWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessWithDependentAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalElementAccess +nullConditionalElementAccessWithDependentAccess original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalElementAccess +nullConditionalElementAccessWithExpression :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.NullConditionalElementAccess +nullConditionalElementAccessWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpression :: Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpression head arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Typed.unTypedTerm head)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionArguments :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) +nullConditionalInvocationExpressionArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the head field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionHead :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHead x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.projectionFieldName = (Model.Name "head")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the element variant of hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadElement :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadElement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "element"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the member variant of hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadMember :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadMember x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadNullConditionalInvocationExpressionHead :: Typed.TypedName Syntax.NullConditionalInvocationExpressionHead +nullConditionalInvocationExpressionHeadNullConditionalInvocationExpressionHead = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead") + +-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionNullConditionalInvocationExpression :: Typed.TypedName Syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionNullConditionalInvocationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression") + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionWithArguments :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.projectionFieldName = (Model.Name "head")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the head field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionWithHead :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression +nullConditionalInvocationExpressionWithHead original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "head"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccess :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalMemberAccess +nullConditionalMemberAccess expression identifier typeArguments dependentAccess = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Typed.unTypedTerm dependentAccess)}]})) + +-- | DSL accessor for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessDependentAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm [Syntax.DependentAccess] +nullConditionalMemberAccessDependentAccess x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessExpression :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression +nullConditionalMemberAccessExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessIdentifier :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.Identifier +nullConditionalMemberAccessIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessNullConditionalMemberAccess :: Typed.TypedName Syntax.NullConditionalMemberAccess +nullConditionalMemberAccessNullConditionalMemberAccess = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessTypeArguments :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +nullConditionalMemberAccessTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithDependentAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithDependentAccess original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithExpression :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithIdentifier :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithTypeArguments :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalMemberAccess +nullConditionalMemberAccessWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dependentAccess"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"), + Model.projectionFieldName = (Model.Name "dependentAccess")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializer :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializer expression identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerExpression :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.PrimaryExpression +nullConditionalProjectionInitializerExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerIdentifier :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.Identifier +nullConditionalProjectionInitializerIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerNullConditionalProjectionInitializer :: Typed.TypedName Syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerNullConditionalProjectionInitializer = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerTypeArguments :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +nullConditionalProjectionInitializerTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithExpression :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithIdentifier :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithTypeArguments :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer +nullConditionalProjectionInitializerWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.NumericType +numericTypeDecimal :: Typed.TypedTerm Syntax.NumericType +numericTypeDecimal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the floatingPoint variant of hydra.ext.csharp.syntax.NumericType +numericTypeFloatingPoint :: Typed.TypedTerm Syntax.FloatingPointType -> Typed.TypedTerm Syntax.NumericType +numericTypeFloatingPoint x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "floatingPoint"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the integral variant of hydra.ext.csharp.syntax.NumericType +numericTypeIntegral :: Typed.TypedTerm Syntax.IntegralType -> Typed.TypedTerm Syntax.NumericType +numericTypeIntegral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integral"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.NumericType +numericTypeNumericType :: Typed.TypedName Syntax.NumericType +numericTypeNumericType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NumericType") + +-- | DSL constructor for hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpression :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Typed.TypedTerm Syntax.ObjectCreationExpression +objectCreationExpression type_ arguments initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionArguments :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) +objectCreationExpressionArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionInitializer :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer) +objectCreationExpressionInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionObjectCreationExpression :: Typed.TypedName Syntax.ObjectCreationExpression +objectCreationExpressionObjectCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionType :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.Type +objectCreationExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionWithArguments :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ObjectCreationExpression +objectCreationExpressionWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Typed.TypedTerm Syntax.ObjectCreationExpression +objectCreationExpressionWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ObjectCreationExpression +objectCreationExpressionWithType :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ObjectCreationExpression +objectCreationExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the collection variant of hydra.ext.csharp.syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerCollection :: Typed.TypedTerm [Syntax.ElementInitializer] -> Typed.TypedTerm Syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.csharp.syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerObject :: Typed.TypedTerm [Syntax.MemberInitializer] -> Typed.TypedTerm Syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerObjectOrCollectionInitializer :: Typed.TypedName Syntax.ObjectOrCollectionInitializer +objectOrCollectionInitializerObjectOrCollectionInitializer = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer") + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.OperatorBody +operatorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.OperatorBody +operatorBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.OperatorBody +operatorBodyEmpty :: Typed.TypedTerm Syntax.OperatorBody +operatorBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.OperatorBody +operatorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.OperatorBody +operatorBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OperatorBody +operatorBodyOperatorBody :: Typed.TypedName Syntax.OperatorBody +operatorBodyOperatorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.OperatorModifier] -> Typed.TypedTerm Syntax.OperatorDeclarator -> Typed.TypedTerm Syntax.OperatorBody -> Typed.TypedTerm Syntax.OperatorDeclaration +operatorDeclaration attributes modifiers declarator body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm declarator)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationAttributes :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +operatorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationBody :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorBody +operatorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationDeclarator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorDeclarator +operatorDeclarationDeclarator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationModifiers :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm [Syntax.OperatorModifier] +operatorDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationOperatorDeclaration :: Typed.TypedName Syntax.OperatorDeclaration +operatorDeclarationOperatorDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationWithAttributes :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.OperatorDeclaration +operatorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationWithBody :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorBody -> Typed.TypedTerm Syntax.OperatorDeclaration +operatorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationWithDeclarator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclaration +operatorDeclarationWithDeclarator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.OperatorDeclaration +operatorDeclarationWithModifiers :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm [Syntax.OperatorModifier] -> Typed.TypedTerm Syntax.OperatorDeclaration +operatorDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.OperatorDeclarator +operatorDeclaratorBinary :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator +operatorDeclaratorBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the conversion variant of hydra.ext.csharp.syntax.OperatorDeclarator +operatorDeclaratorConversion :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator +operatorDeclaratorConversion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "conversion"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OperatorDeclarator +operatorDeclaratorOperatorDeclarator :: Typed.TypedName Syntax.OperatorDeclarator +operatorDeclaratorOperatorDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator") + +-- | DSL injection for the unary variant of hydra.ext.csharp.syntax.OperatorDeclarator +operatorDeclaratorUnary :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator +operatorDeclaratorUnary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.OperatorModifier +operatorModifierExtern :: Typed.TypedTerm Syntax.OperatorModifier +operatorModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OperatorModifier +operatorModifierOperatorModifier :: Typed.TypedName Syntax.OperatorModifier +operatorModifierOperatorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorModifier") + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.OperatorModifier +operatorModifierPublic :: Typed.TypedTerm Syntax.OperatorModifier +operatorModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.OperatorModifier +operatorModifierStatic :: Typed.TypedTerm Syntax.OperatorModifier +operatorModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.OperatorModifier +operatorModifierUnsafe :: Typed.TypedTerm Syntax.OperatorModifier +operatorModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.Ordering +ordering :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.OrderingDirection) -> Typed.TypedTerm Syntax.Ordering +ordering expression direction = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "direction"), + Model.fieldTerm = (Typed.unTypedTerm direction)}]})) + +-- | DSL accessor for the direction field of hydra.ext.csharp.syntax.Ordering +orderingDirection :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm (Maybe Syntax.OrderingDirection) +orderingDirection x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.projectionFieldName = (Model.Name "direction")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the ascending variant of hydra.ext.csharp.syntax.OrderingDirection +orderingDirectionAscending :: Typed.TypedTerm Syntax.OrderingDirection +orderingDirectionAscending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OrderingDirection"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ascending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the descending variant of hydra.ext.csharp.syntax.OrderingDirection +orderingDirectionDescending :: Typed.TypedTerm Syntax.OrderingDirection +orderingDirectionDescending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OrderingDirection"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OrderingDirection +orderingDirectionOrderingDirection :: Typed.TypedName Syntax.OrderingDirection +orderingDirectionOrderingDirection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OrderingDirection") + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.Ordering +orderingExpression :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm Syntax.Expression +orderingExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.Ordering +orderingOrdering :: Typed.TypedName Syntax.Ordering +orderingOrdering = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Ordering") + +-- | DSL updater for the direction field of hydra.ext.csharp.syntax.Ordering +orderingWithDirection :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm (Maybe Syntax.OrderingDirection) -> Typed.TypedTerm Syntax.Ordering +orderingWithDirection original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "direction"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.Ordering +orderingWithExpression :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Ordering +orderingWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "direction"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"), + Model.projectionFieldName = (Model.Name "direction")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the add variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorAdd :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorAdd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "add"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the and variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorAnd :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorAnd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "and"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the divide variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorDivide :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorDivide = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divide"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the equal variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greaterThan variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorGreaterThan :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorGreaterThan = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterThan"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greaterThanOrEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorGreaterThanOrEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorGreaterThanOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterThanOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftShift variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLeftShift :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLeftShift = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftShift"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessThan variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLessThan :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLessThan = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessThan"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessThanOrEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLessThanOrEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorLessThanOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessThanOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the modulus variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorModulus :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorModulus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modulus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the multiply variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorMultiply :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorMultiply = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiply"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the notEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorNotEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorNotEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "notEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the or variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorOr :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorOr = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "or"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorOverloadableBinaryOperator :: Typed.TypedName Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorOverloadableBinaryOperator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator") + +-- | DSL injection for the rightShift variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorRightShift :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorRightShift = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightShift"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the subtract variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorSubtract :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorSubtract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subtract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the xor variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator +overloadableBinaryOperatorXor :: Typed.TypedTerm Syntax.OverloadableBinaryOperator +overloadableBinaryOperatorXor = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "xor"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the complement variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorComplement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorComplement = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "complement"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the decrement variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorDecrement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorDecrement = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decrement"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the false variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorFalse :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorFalse = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the increment variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorIncrement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorIncrement = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "increment"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorMinus :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorMinus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the not variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorNot :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorNot = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorOverloadableUnaryOperator :: Typed.TypedName Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorOverloadableUnaryOperator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator") + +-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorPlus :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorPlus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the true variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator +overloadableUnaryOperatorTrue :: Typed.TypedTerm Syntax.OverloadableUnaryOperator +overloadableUnaryOperatorTrue = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.ParameterArray +parameterArray :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ParameterArray +parameterArray attributes type_ identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayAttributes :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm (Maybe Syntax.Attributes) +parameterArrayAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayIdentifier :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.Identifier +parameterArrayIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.ParameterArray +parameterArrayParameterArray :: Typed.TypedName Syntax.ParameterArray +parameterArrayParameterArray = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterArray") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayType :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.ArrayType +parameterArrayType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayWithAttributes :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ParameterArray +parameterArrayWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayWithIdentifier :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ParameterArray +parameterArrayWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.ParameterArray +parameterArrayWithType :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ParameterArray +parameterArrayWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the in variant of hydra.ext.csharp.syntax.ParameterModeModifier +parameterModeModifierIn :: Typed.TypedTerm Syntax.ParameterModeModifier +parameterModeModifierIn = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the out variant of hydra.ext.csharp.syntax.ParameterModeModifier +parameterModeModifierOut :: Typed.TypedTerm Syntax.ParameterModeModifier +parameterModeModifierOut = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "out"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ParameterModeModifier +parameterModeModifierParameterModeModifier :: Typed.TypedName Syntax.ParameterModeModifier +parameterModeModifierParameterModeModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ParameterModeModifier +parameterModeModifierRef :: Typed.TypedTerm Syntax.ParameterModeModifier +parameterModeModifierRef = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the mode variant of hydra.ext.csharp.syntax.ParameterModifier +parameterModifierMode :: Typed.TypedTerm Syntax.ParameterModeModifier -> Typed.TypedTerm Syntax.ParameterModifier +parameterModifierMode x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ParameterModifier +parameterModifierParameterModifier :: Typed.TypedName Syntax.ParameterModifier +parameterModifierParameterModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterModifier") + +-- | DSL injection for the this variant of hydra.ext.csharp.syntax.ParameterModifier +parameterModifierThis :: Typed.TypedTerm Syntax.ParameterModifier +parameterModifierThis = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "this"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.Pattern +patternConstant :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Pattern +patternConstant x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constant"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.Pattern +patternDeclaration :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Pattern +patternDeclaration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.Pattern +patternPattern :: Typed.TypedName Syntax.Pattern +patternPattern = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Pattern") + +-- | DSL injection for the var variant of hydra.ext.csharp.syntax.Pattern +patternVar :: Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.Pattern +patternVar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "var"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PointerElementAccess +pointerElementAccess pointer index = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm pointer)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm index)}]})) + +-- | DSL accessor for the index field of hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccessIndex :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.Expression +pointerElementAccessIndex x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pointer field of hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccessPointer :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +pointerElementAccessPointer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccessPointerElementAccess :: Typed.TypedName Syntax.PointerElementAccess +pointerElementAccessPointerElementAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess") + +-- | DSL updater for the index field of hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccessWithIndex :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PointerElementAccess +pointerElementAccessWithIndex original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the pointer field of hydra.ext.csharp.syntax.PointerElementAccess +pointerElementAccessWithPointer :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.PointerElementAccess +pointerElementAccessWithPointer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccess :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.PointerMemberAccess +pointerMemberAccess pointer member typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm pointer)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm member)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL accessor for the member field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessMember :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.Identifier +pointerMemberAccessMember x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pointer field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessPointer :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression +pointerMemberAccessPointer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessPointerMemberAccess :: Typed.TypedName Syntax.PointerMemberAccess +pointerMemberAccessPointerMemberAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessTypeArguments :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +pointerMemberAccessTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the member field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessWithMember :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.PointerMemberAccess +pointerMemberAccessWithMember original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pointer field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessWithPointer :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PointerMemberAccess +pointerMemberAccessWithPointer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.PointerMemberAccess +pointerMemberAccessWithTypeArguments :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.PointerMemberAccess +pointerMemberAccessWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "pointer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the pointerDepth variant of hydra.ext.csharp.syntax.PointerType +pointerTypePointerDepth :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.PointerType +pointerTypePointerDepth x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointerDepth"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PointerType +pointerTypePointerType :: Typed.TypedName Syntax.PointerType +pointerTypePointerType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerType") + +-- | DSL injection for the valueType variant of hydra.ext.csharp.syntax.PointerType +pointerTypeValueType :: Typed.TypedTerm (Maybe Syntax.ValueType) -> Typed.TypedTerm Syntax.PointerType +pointerTypeValueType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.PositionalArgument +positionalArgument :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.PositionalArgument +positionalArgument name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.PositionalArgumentList wrapper +positionalArgumentList :: Typed.TypedTerm [Syntax.PositionalArgument] -> Typed.TypedTerm Syntax.PositionalArgumentList +positionalArgumentList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.PositionalArgumentList +positionalArgumentListPositionalArgumentList :: Typed.TypedName Syntax.PositionalArgumentList +positionalArgumentListPositionalArgumentList = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList") + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.PositionalArgument +positionalArgumentName :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm (Maybe Syntax.Identifier) +positionalArgumentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.PositionalArgument +positionalArgumentPositionalArgument :: Typed.TypedName Syntax.PositionalArgument +positionalArgumentPositionalArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PositionalArgument") + +-- | DSL accessor for the value field of hydra.ext.csharp.syntax.PositionalArgument +positionalArgumentValue :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression +positionalArgumentValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.PositionalArgument +positionalArgumentWithName :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.PositionalArgument +positionalArgumentWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.csharp.syntax.PositionalArgument +positionalArgumentWithValue :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.PositionalArgument +positionalArgumentWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the bool variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeBool :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeBool = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bool"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the byte variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeByte :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeByte = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byte"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the char variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeChar :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeChar = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "char"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeDecimal :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeDecimal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeDouble :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeFloat :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeInt :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the long variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeLong :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the object variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeObject :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeObject = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PredefinedType +predefinedTypePredefinedType :: Typed.TypedName Syntax.PredefinedType +predefinedTypePredefinedType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PredefinedType") + +-- | DSL injection for the sbyte variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeSbyte :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeSbyte = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sbyte"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the short variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeShort :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeShort = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "short"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeString :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uint variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeUint :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeUint = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uint"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ulong variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeUlong :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeUlong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ulong"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ushort variant of hydra.ext.csharp.syntax.PredefinedType +predefinedTypeUshort :: Typed.TypedTerm Syntax.PredefinedType +predefinedTypeUshort = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ushort"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the class variant of hydra.ext.csharp.syntax.PrimaryConstraint +primaryConstraintClass :: Typed.TypedTerm Syntax.PrimaryConstraint +primaryConstraintClass = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the classType variant of hydra.ext.csharp.syntax.PrimaryConstraint +primaryConstraintClassType :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.PrimaryConstraint +primaryConstraintClassType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "classType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PrimaryConstraint +primaryConstraintPrimaryConstraint :: Typed.TypedName Syntax.PrimaryConstraint +primaryConstraintPrimaryConstraint = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint") + +-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.PrimaryConstraint +primaryConstraintStruct :: Typed.TypedTerm Syntax.PrimaryConstraint +primaryConstraintStruct = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unmanaged variant of hydra.ext.csharp.syntax.PrimaryConstraint +primaryConstraintUnmanaged :: Typed.TypedTerm Syntax.PrimaryConstraint +primaryConstraintUnmanaged = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unmanaged"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the array variant of hydra.ext.csharp.syntax.PrimaryExpression +primaryExpressionArray :: Typed.TypedTerm Syntax.ArrayCreationExpression -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the noArray variant of hydra.ext.csharp.syntax.PrimaryExpression +primaryExpressionNoArray :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.PrimaryExpression +primaryExpressionNoArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "noArray"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PrimaryExpression +primaryExpressionPrimaryExpression :: Typed.TypedName Syntax.PrimaryExpression +primaryExpressionPrimaryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression") + +-- | DSL injection for the anonymousMethod variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionAnonymousMethod :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionAnonymousMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "anonymousMethod"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the anonymousObjectCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionAnonymousObjectCreation :: Typed.TypedTerm (Maybe Syntax.MemberDeclaratorList) -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionAnonymousObjectCreation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "anonymousObjectCreation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the baseAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionBaseAccess :: Typed.TypedTerm Syntax.BaseAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionBaseAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "baseAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the checked variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionChecked :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionChecked x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "checked"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the defaultValue variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionDefaultValue :: Typed.TypedTerm Syntax.DefaultValueExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionDefaultValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "defaultValue"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the delegateCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionDelegateCreation :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionDelegateCreation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "delegateCreation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the elementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionElementAccess :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionElementAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "elementAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interpolatedString variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionInterpolatedString :: Typed.TypedTerm Syntax.InterpolatedStringExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionInterpolatedString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interpolatedString"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionInvocation :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "invocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the literal variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionLiteral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "literal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionMemberAccess :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "memberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nameof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNameof :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNameof x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nameof"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nullConditionalElementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNullConditionalElementAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNullConditionalElementAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalElementAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nullConditionalMemberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNullConditionalMemberAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionNullConditionalMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalMemberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the objectCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionObjectCreation :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionObjectCreation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "objectCreation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parenthesized variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionParenthesized :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionParenthesized x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parenthesized"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pointerElementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPointerElementAccess :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPointerElementAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointerElementAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pointerMemberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPointerMemberAccess :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPointerMemberAccess x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointerMemberAccess"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postDecrement variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPostDecrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPostDecrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postDecrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postIncrement variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPostIncrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPostIncrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postIncrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPrimaryNoArrayCreationExpression :: Typed.TypedName Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionPrimaryNoArrayCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression") + +-- | DSL injection for the simpleName variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionSimpleName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionSimpleName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simpleName"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the sizeof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionSizeof :: Typed.TypedTerm Syntax.UnmanagedType -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionSizeof x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sizeof"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the stackalloc variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionStackalloc :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionStackalloc x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "stackalloc"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the thisAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionThisAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionThisAccess = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "thisAccess"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionTuple :: Typed.TypedTerm Syntax.TupleExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionTuple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "tuple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionTypeof :: Typed.TypedTerm Syntax.TypeofExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionTypeof x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeof"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unchecked variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionUnchecked :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression +primaryNoArrayCreationExpressionUnchecked x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unchecked"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.PropertyBody +propertyBodyBlock :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.PropertyBody +propertyBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.PropertyBody +propertyBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PropertyBody +propertyBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PropertyBody +propertyBodyPropertyBody :: Typed.TypedName Syntax.PropertyBody +propertyBodyPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyBody") + +-- | DSL name token for hydra.ext.csharp.syntax.PropertyDeclaration +propertyDeclarationPropertyDeclaration :: Typed.TypedName Syntax.PropertyDeclaration +propertyDeclarationPropertyDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration") + +-- | DSL injection for the refReturn variant of hydra.ext.csharp.syntax.PropertyDeclaration +propertyDeclarationRefReturn :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyDeclaration +propertyDeclarationRefReturn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "refReturn"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.PropertyDeclaration +propertyDeclarationStandard :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyDeclaration +propertyDeclarationStandard x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "standard"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierAbstract :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierAbstract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "abstract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierExtern :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierInternal :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierNew :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the override variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierOverride :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierOverride = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierPrivate :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.PropertyModifier +propertyModifierPropertyModifier :: Typed.TypedName Syntax.PropertyModifier +propertyModifierPropertyModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyModifier") + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierProtected :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierPublic :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierSealed :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierSealed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sealed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierStatic :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierUnsafe :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.PropertyModifier +propertyModifierVirtual :: Typed.TypedTerm Syntax.PropertyModifier +propertyModifierVirtual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "virtual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMember :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedAliasMember +qualifiedAliasMember alias member arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm member)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the alias field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier +qualifiedAliasMemberAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberArguments :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +qualifiedAliasMemberArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the member field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier +qualifiedAliasMemberMember x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberQualifiedAliasMember :: Typed.TypedName Syntax.QualifiedAliasMember +qualifiedAliasMemberQualifiedAliasMember = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember") + +-- | DSL updater for the alias field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberWithAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedAliasMember +qualifiedAliasMemberWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberWithArguments :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedAliasMember +qualifiedAliasMemberWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "member")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the member field of hydra.ext.csharp.syntax.QualifiedAliasMember +qualifiedAliasMemberWithMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedAliasMember +qualifiedAliasMemberWithMember original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "member"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.QualifiedIdentifier wrapper +qualifiedIdentifier :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.QualifiedIdentifier +qualifiedIdentifier x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QualifiedIdentifier +qualifiedIdentifierQualifiedIdentifier :: Typed.TypedName Syntax.QualifiedIdentifier +qualifiedIdentifierQualifiedIdentifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier") + +-- | DSL constructor for hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeName namespaceOrType identifier arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaceOrType"), + Model.fieldTerm = (Typed.unTypedTerm namespaceOrType)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameArguments :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +qualifiedNamespaceOrTypeNameArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier +qualifiedNamespaceOrTypeNameIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespaceOrType field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameNamespaceOrType :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName +qualifiedNamespaceOrTypeNameNamespaceOrType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "namespaceOrType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameQualifiedNamespaceOrTypeName :: Typed.TypedName Syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameQualifiedNamespaceOrTypeName = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName") + +-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithArguments :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaceOrType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "namespaceOrType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithIdentifier :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaceOrType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "namespaceOrType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the namespaceOrType field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithNamespaceOrType :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName +qualifiedNamespaceOrTypeNameWithNamespaceOrType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespaceOrType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.QueryBody +queryBody :: Typed.TypedTerm [Syntax.QueryBodyClause] -> Typed.TypedTerm Syntax.SelectOrGroupClause -> Typed.TypedTerm (Maybe Syntax.QueryContinuation) -> Typed.TypedTerm Syntax.QueryBody +queryBody clauses selectOrGroup continuation = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "clauses"), + Model.fieldTerm = (Typed.unTypedTerm clauses)}, + Model.Field { + Model.fieldName = (Model.Name "selectOrGroup"), + Model.fieldTerm = (Typed.unTypedTerm selectOrGroup)}, + Model.Field { + Model.fieldName = (Model.Name "continuation"), + Model.fieldTerm = (Typed.unTypedTerm continuation)}]})) + +-- | DSL injection for the from variant of hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseFrom :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryBodyClause +queryBodyClauseFrom x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "from"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the join variant of hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseJoin :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.QueryBodyClause +queryBodyClauseJoin x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "join"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the let variant of hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseLet :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.QueryBodyClause +queryBodyClauseLet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "let"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the orderby variant of hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseOrderby :: Typed.TypedTerm [Syntax.Ordering] -> Typed.TypedTerm Syntax.QueryBodyClause +queryBodyClauseOrderby x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "orderby"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseQueryBodyClause :: Typed.TypedName Syntax.QueryBodyClause +queryBodyClauseQueryBodyClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause") + +-- | DSL injection for the where variant of hydra.ext.csharp.syntax.QueryBodyClause +queryBodyClauseWhere :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.QueryBodyClause +queryBodyClauseWhere x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "where"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the clauses field of hydra.ext.csharp.syntax.QueryBody +queryBodyClauses :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm [Syntax.QueryBodyClause] +queryBodyClauses x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "clauses")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the continuation field of hydra.ext.csharp.syntax.QueryBody +queryBodyContinuation :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm (Maybe Syntax.QueryContinuation) +queryBodyContinuation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "continuation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QueryBody +queryBodyQueryBody :: Typed.TypedName Syntax.QueryBody +queryBodyQueryBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryBody") + +-- | DSL accessor for the selectOrGroup field of hydra.ext.csharp.syntax.QueryBody +queryBodySelectOrGroup :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.SelectOrGroupClause +queryBodySelectOrGroup x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "selectOrGroup")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the clauses field of hydra.ext.csharp.syntax.QueryBody +queryBodyWithClauses :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm [Syntax.QueryBodyClause] -> Typed.TypedTerm Syntax.QueryBody +queryBodyWithClauses original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "clauses"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "selectOrGroup"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "selectOrGroup")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "continuation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "continuation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the continuation field of hydra.ext.csharp.syntax.QueryBody +queryBodyWithContinuation :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm (Maybe Syntax.QueryContinuation) -> Typed.TypedTerm Syntax.QueryBody +queryBodyWithContinuation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "clauses"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "clauses")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selectOrGroup"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "selectOrGroup")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "continuation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the selectOrGroup field of hydra.ext.csharp.syntax.QueryBody +queryBodyWithSelectOrGroup :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.SelectOrGroupClause -> Typed.TypedTerm Syntax.QueryBody +queryBodyWithSelectOrGroup original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "clauses"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "clauses")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selectOrGroup"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "continuation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"), + Model.projectionFieldName = (Model.Name "continuation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.QueryContinuation +queryContinuation :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryContinuation +queryContinuation into body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Typed.unTypedTerm into)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.QueryContinuation +queryContinuationBody :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.QueryBody +queryContinuationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the into field of hydra.ext.csharp.syntax.QueryContinuation +queryContinuationInto :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.Identifier +queryContinuationInto x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QueryContinuation +queryContinuationQueryContinuation :: Typed.TypedName Syntax.QueryContinuation +queryContinuationQueryContinuation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryContinuation") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.QueryContinuation +queryContinuationWithBody :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryContinuation +queryContinuationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.projectionFieldName = (Model.Name "into")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the into field of hydra.ext.csharp.syntax.QueryContinuation +queryContinuationWithInto :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QueryContinuation +queryContinuationWithInto original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "into"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.QueryExpression +queryExpression :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryExpression +queryExpression from body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "from"), + Model.fieldTerm = (Typed.unTypedTerm from)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.QueryExpression +queryExpressionBody :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.QueryBody +queryExpressionBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the from field of hydra.ext.csharp.syntax.QueryExpression +queryExpressionFrom :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.FromClause +queryExpressionFrom x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.projectionFieldName = (Model.Name "from")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.QueryExpression +queryExpressionQueryExpression :: Typed.TypedName Syntax.QueryExpression +queryExpressionQueryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryExpression") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.QueryExpression +queryExpressionWithBody :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryExpression +queryExpressionWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "from"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.projectionFieldName = (Model.Name "from")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the from field of hydra.ext.csharp.syntax.QueryExpression +queryExpressionWithFrom :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryExpression +queryExpressionWithFrom original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "from"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.RankSpecifier wrapper +rankSpecifier :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.RankSpecifier +rankSpecifier x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifier"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpression :: Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpression rankSpecifier initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rankSpecifier"), + Model.fieldTerm = (Typed.unTypedTerm rankSpecifier)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer +rankSpecifierArrayCreationExpressionInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rankSpecifier field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.RankSpecifier +rankSpecifierArrayCreationExpressionRankSpecifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionRankSpecifierArrayCreationExpression :: Typed.TypedName Syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionRankSpecifierArrayCreationExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression") + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rankSpecifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "rankSpecifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the rankSpecifier field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionWithRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression +rankSpecifierArrayCreationExpressionWithRankSpecifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rankSpecifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.RankSpecifier +rankSpecifierRankSpecifier :: Typed.TypedName Syntax.RankSpecifier +rankSpecifierRankSpecifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RankSpecifier") + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefAccessorBody +refAccessorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefAccessorBody +refAccessorBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.RefAccessorBody +refAccessorBodyEmpty :: Typed.TypedTerm Syntax.RefAccessorBody +refAccessorBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefAccessorBody +refAccessorBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefAccessorBody +refAccessorBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefAccessorBody +refAccessorBodyRefAccessorBody :: Typed.TypedName Syntax.RefAccessorBody +refAccessorBodyRefAccessorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpression :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression +refConditionalExpression condition true false = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Typed.unTypedTerm true)}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Typed.unTypedTerm false)}]})) + +-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionCondition :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +refConditionalExpressionCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the false field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionFalse :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference +refConditionalExpressionFalse x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionRefConditionalExpression :: Typed.TypedName Syntax.RefConditionalExpression +refConditionalExpressionRefConditionalExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression") + +-- | DSL accessor for the true field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionTrue :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference +refConditionalExpressionTrue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the condition field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionWithCondition :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.RefConditionalExpression +refConditionalExpressionWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the false field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionWithFalse :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression +refConditionalExpressionWithFalse original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the true field of hydra.ext.csharp.syntax.RefConditionalExpression +refConditionalExpressionWithTrue :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression +refConditionalExpressionWithTrue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.RefAccessorBody -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration +refGetAccessorDeclaration attributes modifier body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm modifier)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationAttributes :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +refGetAccessorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationBody :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefAccessorBody +refGetAccessorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationModifier :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) +refGetAccessorDeclarationModifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationRefGetAccessorDeclaration :: Typed.TypedName Syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationRefGetAccessorDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithBody :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefAccessorBody -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "modifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithModifier :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration +refGetAccessorDeclarationWithModifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefIndexerBody +refIndexerBodyBlock :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody +refIndexerBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefIndexerBody +refIndexerBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefIndexerBody +refIndexerBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefIndexerBody +refIndexerBodyRefIndexerBody :: Typed.TypedName Syntax.RefIndexerBody +refIndexerBodyRefIndexerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.RefIndexerBody -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclaration attributes modifiers refKind declarator body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm declarator)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +refIndexerDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationBody :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody +refIndexerDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationDeclarator :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator +refIndexerDeclarationDeclarator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationModifiers :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] +refIndexerDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationRefIndexerDeclaration :: Typed.TypedName Syntax.RefIndexerDeclaration +refIndexerDeclarationRefIndexerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration") + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationRefKind :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefKind +refIndexerDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationWithBody :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationWithDeclarator :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclarationWithDeclarator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefIndexerDeclaration +refIndexerDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefIndexerDeclaration +refIndexerDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefKind +refKindRef :: Typed.TypedTerm Syntax.RefKind +refKindRef = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefKind +refKindRefKind :: Typed.TypedName Syntax.RefKind +refKindRefKind = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefKind") + +-- | DSL injection for the refReadonly variant of hydra.ext.csharp.syntax.RefKind +refKindRefReadonly :: Typed.TypedTerm Syntax.RefKind +refKindRefReadonly = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "refReadonly"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefLocalFunctionBody +refLocalFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefLocalFunctionBody +refLocalFunctionBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefLocalFunctionBody +refLocalFunctionBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalFunctionBody +refLocalFunctionBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionBody +refLocalFunctionBodyRefLocalFunctionBody :: Typed.TypedName Syntax.RefLocalFunctionBody +refLocalFunctionBodyRefLocalFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclaration :: Typed.TypedTerm [Syntax.RefLocalFunctionModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.RefLocalFunctionBody -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclaration modifiers refKind returnType header body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationBody :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefLocalFunctionBody +refLocalFunctionDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationHeader :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader +refLocalFunctionDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationModifiers :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.RefLocalFunctionModifier] +refLocalFunctionDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationRefKind :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefKind +refLocalFunctionDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationRefLocalFunctionDeclaration :: Typed.TypedName Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationRefLocalFunctionDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration") + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationReturnType :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.Type +refLocalFunctionDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithBody :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefLocalFunctionBody -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithHeader :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.RefLocalFunctionModifier] -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithReturnType :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration +refLocalFunctionDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionModifier +refLocalFunctionModifierRefLocalFunctionModifier :: Typed.TypedName Syntax.RefLocalFunctionModifier +refLocalFunctionModifierRefLocalFunctionModifier = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier") + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.RefLocalFunctionModifier +refLocalFunctionModifierStatic :: Typed.TypedTerm Syntax.RefLocalFunctionModifier +refLocalFunctionModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.RefLocalFunctionModifier +refLocalFunctionModifierUnsafe :: Typed.TypedTerm Syntax.RefLocalFunctionModifier +refLocalFunctionModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclaration :: Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator] -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration +refLocalVariableDeclaration refKind type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationDeclarators :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator] +refLocalVariableDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationRefKind :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind +refLocalVariableDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationRefLocalVariableDeclaration :: Typed.TypedName Syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationRefLocalVariableDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationType :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type +refLocalVariableDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithDeclarators :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator] -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithType :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration +refLocalVariableDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator +refLocalVariableDeclarator left right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL accessor for the left field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorLeft :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier +refLocalVariableDeclaratorLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorRefLocalVariableDeclarator :: Typed.TypedName Syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorRefLocalVariableDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator") + +-- | DSL accessor for the right field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorRight :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.VariableReference +refLocalVariableDeclaratorRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorWithLeft :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorWithRight :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator +refLocalVariableDeclaratorWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefMethodBody +refMethodBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefMethodBody +refMethodBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.RefMethodBody +refMethodBodyEmpty :: Typed.TypedTerm Syntax.RefMethodBody +refMethodBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefMethodBody +refMethodBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefMethodBody +refMethodBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefMethodBody +refMethodBodyRefMethodBody :: Typed.TypedName Syntax.RefMethodBody +refMethodBodyRefMethodBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefMethodBody") + +-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierAbstract :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierAbstract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "abstract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierExtern :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierExtern = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierInternal :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierNew :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the override variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierOverride :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierOverride = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierPrivate :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierProtected :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierPublic :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierRefMethodModifier :: Typed.TypedName Syntax.RefMethodModifier +refMethodModifierRefMethodModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier") + +-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierSealed :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierSealed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sealed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierStatic :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierStatic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierUnsafe :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.RefMethodModifier +refMethodModifierVirtual :: Typed.TypedTerm Syntax.RefMethodModifier +refMethodModifierVirtual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "virtual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefPropertyBody +refPropertyBodyBlock :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody +refPropertyBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefPropertyBody +refPropertyBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefPropertyBody +refPropertyBodyRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefPropertyBody +refPropertyBodyRefPropertyBody :: Typed.TypedName Syntax.RefPropertyBody +refPropertyBodyRefPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.RefMethodModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.RefMethodBody -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclaration attributes modifiers kind returnType header body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationAttributes :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +refReturnMethodDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationBody :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefMethodBody +refReturnMethodDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationHeader :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader +refReturnMethodDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationKind :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefKind +refReturnMethodDeclarationKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationModifiers :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm [Syntax.RefMethodModifier] +refReturnMethodDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationRefReturnMethodDeclaration :: Typed.TypedName Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationRefReturnMethodDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration") + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationReturnType :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType +refReturnMethodDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithBody :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefMethodBody -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the kind field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithKind :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm [Syntax.RefMethodModifier] -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration +refReturnMethodDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.RefPropertyBody -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclaration attributes modifiers refKind type_ name body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationAttributes :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +refReturnPropertyDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationBody :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody +refReturnPropertyDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationModifiers :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] +refReturnPropertyDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationName :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName +refReturnPropertyDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationRefKind :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefKind +refReturnPropertyDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationRefReturnPropertyDeclaration :: Typed.TypedName Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationRefReturnPropertyDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationType :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.Type +refReturnPropertyDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithBody :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithName :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithType :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration +refReturnPropertyDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclaration :: Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclaration refKind declarator = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm refKind)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm declarator)}]})) + +-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator +refVarImplicitlyTypedLocalVariableDeclarationDeclarator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationRefKind :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind +refVarImplicitlyTypedLocalVariableDeclarationRefKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationRefVarImplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationRefVarImplicitlyTypedLocalVariableDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration") + +-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "refKind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration +refVarImplicitlyTypedLocalVariableDeclarationWithRefKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "refKind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the array variant of hydra.ext.csharp.syntax.ReferenceType +referenceTypeArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ReferenceType +referenceTypeArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the class variant of hydra.ext.csharp.syntax.ReferenceType +referenceTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ReferenceType +referenceTypeClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.ReferenceType +referenceTypeDelegate :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.ReferenceType +referenceTypeDelegate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "delegate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the dynamic variant of hydra.ext.csharp.syntax.ReferenceType +referenceTypeDynamic :: Typed.TypedTerm Syntax.ReferenceType +referenceTypeDynamic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dynamic"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.ReferenceType +referenceTypeInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.ReferenceType +referenceTypeInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ReferenceType +referenceTypeReferenceType :: Typed.TypedName Syntax.ReferenceType +referenceTypeReferenceType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReferenceType") + +-- | DSL constructor for hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RegularInterpolation +regularInterpolation expression width format = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Typed.unTypedTerm width)}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Typed.unTypedTerm format)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationExpression :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm Syntax.Expression +regularInterpolationExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the format field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationFormat :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe String) +regularInterpolationFormat x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationRegularInterpolation :: Typed.TypedName Syntax.RegularInterpolation +regularInterpolationRegularInterpolation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation") + +-- | DSL accessor for the width field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationWidth :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe Syntax.Expression) +regularInterpolationWidth x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationWithExpression :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RegularInterpolation +regularInterpolationWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the format field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationWithFormat :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RegularInterpolation +regularInterpolationWithFormat original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the width field of hydra.ext.csharp.syntax.RegularInterpolation +regularInterpolationWithWidth :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.RegularInterpolation +regularInterpolationWithWidth original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the asType variant of hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionAsType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionAsType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "asType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionBinary :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the isPattern variant of hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionIsPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionIsPattern x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "isPattern"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the isType variant of hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionIsType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionIsType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "isType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionRelationalExpression :: Typed.TypedName Syntax.RelationalExpression +relationalExpressionRelationalExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RelationalExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.RelationalExpression +relationalExpressionSimple :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression +relationalExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the greaterThan variant of hydra.ext.csharp.syntax.RelationalOperator +relationalOperatorGreaterThan :: Typed.TypedTerm Syntax.RelationalOperator +relationalOperatorGreaterThan = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterThan"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greaterThanOrEqual variant of hydra.ext.csharp.syntax.RelationalOperator +relationalOperatorGreaterThanOrEqual :: Typed.TypedTerm Syntax.RelationalOperator +relationalOperatorGreaterThanOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterThanOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessThan variant of hydra.ext.csharp.syntax.RelationalOperator +relationalOperatorLessThan :: Typed.TypedTerm Syntax.RelationalOperator +relationalOperatorLessThan = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessThan"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessThanOrEqual variant of hydra.ext.csharp.syntax.RelationalOperator +relationalOperatorLessThanOrEqual :: Typed.TypedTerm Syntax.RelationalOperator +relationalOperatorLessThanOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessThanOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.RelationalOperator +relationalOperatorRelationalOperator :: Typed.TypedName Syntax.RelationalOperator +relationalOperatorRelationalOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RelationalOperator") + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ResourceAcquisition +resourceAcquisitionExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ResourceAcquisition +resourceAcquisitionExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the local variant of hydra.ext.csharp.syntax.ResourceAcquisition +resourceAcquisitionLocal :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.ResourceAcquisition +resourceAcquisitionLocal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "local"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ResourceAcquisition +resourceAcquisitionResourceAcquisition :: Typed.TypedName Syntax.ResourceAcquisition +resourceAcquisitionResourceAcquisition = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition") + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ReturnStatement +returnStatementRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ReturnStatement +returnStatementRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ReturnStatement +returnStatementReturnStatement :: Typed.TypedName Syntax.ReturnStatement +returnStatementReturnStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReturnStatement") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ReturnStatement +returnStatementSimple :: Typed.TypedTerm Syntax.ReturnStatement +returnStatementSimple = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the value variant of hydra.ext.csharp.syntax.ReturnStatement +returnStatementValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ReturnStatement +returnStatementValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ReturnType +returnTypeRef :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ReturnType +returnTypeRef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ReturnType +returnTypeReturnType :: Typed.TypedName Syntax.ReturnType +returnTypeReturnType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReturnType") + +-- | DSL injection for the void variant of hydra.ext.csharp.syntax.ReturnType +returnTypeVoid :: Typed.TypedTerm Syntax.ReturnType +returnTypeVoid = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "void"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.SecondaryConstraint +secondaryConstraintInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.SecondaryConstraint +secondaryConstraintInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parameter variant of hydra.ext.csharp.syntax.SecondaryConstraint +secondaryConstraintParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.SecondaryConstraint +secondaryConstraintParameter x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.SecondaryConstraint +secondaryConstraintSecondaryConstraint :: Typed.TypedName Syntax.SecondaryConstraint +secondaryConstraintSecondaryConstraint = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint") + +-- | DSL constructor for the hydra.ext.csharp.syntax.SecondaryConstraints wrapper +secondaryConstraints :: Typed.TypedTerm [Syntax.SecondaryConstraint] -> Typed.TypedTerm Syntax.SecondaryConstraints +secondaryConstraints x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SecondaryConstraints +secondaryConstraintsSecondaryConstraints :: Typed.TypedName Syntax.SecondaryConstraints +secondaryConstraintsSecondaryConstraints = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints") + +-- | DSL injection for the group variant of hydra.ext.csharp.syntax.SelectOrGroupClause +selectOrGroupClauseGroup :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.SelectOrGroupClause +selectOrGroupClauseGroup x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the select variant of hydra.ext.csharp.syntax.SelectOrGroupClause +selectOrGroupClauseSelect :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SelectOrGroupClause +selectOrGroupClauseSelect x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "select"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.SelectOrGroupClause +selectOrGroupClauseSelectOrGroupClause :: Typed.TypedName Syntax.SelectOrGroupClause +selectOrGroupClauseSelectOrGroupClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause") + +-- | DSL injection for the if variant of hydra.ext.csharp.syntax.SelectionStatement +selectionStatementIf :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatementIf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectionStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "if"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.SelectionStatement +selectionStatementSelectionStatement :: Typed.TypedName Syntax.SelectionStatement +selectionStatementSelectionStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SelectionStatement") + +-- | DSL injection for the switch variant of hydra.ext.csharp.syntax.SelectionStatement +selectionStatementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.SelectionStatement +selectionStatementSwitch x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectionStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "switch"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ShiftExpression +shiftExpressionBinary :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression +shiftExpressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ShiftExpression +shiftExpressionShiftExpression :: Typed.TypedName Syntax.ShiftExpression +shiftExpressionShiftExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ShiftExpression") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ShiftExpression +shiftExpressionSimple :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression +shiftExpressionSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the left variant of hydra.ext.csharp.syntax.ShiftOperator +shiftOperatorLeft :: Typed.TypedTerm Syntax.ShiftOperator +shiftOperatorLeft = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the right variant of hydra.ext.csharp.syntax.ShiftOperator +shiftOperatorRight :: Typed.TypedTerm Syntax.ShiftOperator +shiftOperatorRight = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ShiftOperator +shiftOperatorShiftOperator :: Typed.TypedName Syntax.ShiftOperator +shiftOperatorShiftOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ShiftOperator") + +-- | DSL constructor for hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpression :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression +simpleConditionalExpression condition true false = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Typed.unTypedTerm true)}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Typed.unTypedTerm false)}]})) + +-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionCondition :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression +simpleConditionalExpressionCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the false field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionFalse :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression +simpleConditionalExpressionFalse x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionSimpleConditionalExpression :: Typed.TypedName Syntax.SimpleConditionalExpression +simpleConditionalExpressionSimpleConditionalExpression = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression") + +-- | DSL accessor for the true field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionTrue :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression +simpleConditionalExpressionTrue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the condition field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionWithCondition :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.SimpleConditionalExpression +simpleConditionalExpressionWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the false field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionWithFalse :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression +simpleConditionalExpressionWithFalse original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "true")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the true field of hydra.ext.csharp.syntax.SimpleConditionalExpression +simpleConditionalExpressionWithTrue :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression +simpleConditionalExpressionWithTrue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "true"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "false"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"), + Model.projectionFieldName = (Model.Name "false")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.SimpleName +simpleName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.SimpleName +simpleName identifier typeArguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.SimpleName +simpleNameIdentifier :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.Identifier +simpleNameIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SimpleName +simpleNameSimpleName :: Typed.TypedName Syntax.SimpleName +simpleNameSimpleName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleName") + +-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.SimpleName +simpleNameTypeArguments :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) +simpleNameTypeArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.SimpleName +simpleNameWithIdentifier :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SimpleName +simpleNameWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.projectionFieldName = (Model.Name "typeArguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.SimpleName +simpleNameWithTypeArguments :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.SimpleName +simpleNameWithTypeArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeArguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the bool variant of hydra.ext.csharp.syntax.SimpleType +simpleTypeBool :: Typed.TypedTerm Syntax.SimpleType +simpleTypeBool = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bool"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the numeric variant of hydra.ext.csharp.syntax.SimpleType +simpleTypeNumeric :: Typed.TypedTerm Syntax.NumericType -> Typed.TypedTerm Syntax.SimpleType +simpleTypeNumeric x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "numeric"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.SimpleType +simpleTypeSimpleType :: Typed.TypedName Syntax.SimpleType +simpleTypeSimpleType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleType") + +-- | DSL constructor for hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClause :: Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier) -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SpecificCatchClause +specificCatchClause specifier filter body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Typed.unTypedTerm specifier)}, + Model.Field { + Model.fieldName = (Model.Name "filter"), + Model.fieldTerm = (Typed.unTypedTerm filter)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseBody :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm Syntax.Block +specificCatchClauseBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the filter field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseFilter :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) +specificCatchClauseFilter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "filter")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseSpecificCatchClause :: Typed.TypedName Syntax.SpecificCatchClause +specificCatchClauseSpecificCatchClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause") + +-- | DSL accessor for the specifier field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseSpecifier :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier) +specificCatchClauseSpecifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "specifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseWithBody :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SpecificCatchClause +specificCatchClauseWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "specifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "filter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "filter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the filter field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseWithFilter :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.SpecificCatchClause +specificCatchClauseWithFilter original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "specifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "filter"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the specifier field of hydra.ext.csharp.syntax.SpecificCatchClause +specificCatchClauseWithSpecifier :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier) -> Typed.TypedTerm Syntax.SpecificCatchClause +specificCatchClauseWithSpecifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "specifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "filter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "filter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StackallocExpression +stackallocExpression :: Typed.TypedTerm (Maybe Syntax.UnmanagedType) -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.StackallocExpression +stackallocExpression type_ expression initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionExpression :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) +stackallocExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionInitializer :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm [Syntax.Expression] +stackallocExpressionInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionStackallocExpression :: Typed.TypedName Syntax.StackallocExpression +stackallocExpressionStackallocExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StackallocExpression") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionType :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.UnmanagedType) +stackallocExpressionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionWithExpression :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.StackallocExpression +stackallocExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionWithInitializer :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.StackallocExpression +stackallocExpressionWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.StackallocExpression +stackallocExpressionWithType :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.UnmanagedType) -> Typed.TypedTerm Syntax.StackallocExpression +stackallocExpressionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm Syntax.StandardEventDeclaration +standardEventDeclaration attributes modifiers type_ declarators = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm declarators)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationAttributes :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +standardEventDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationDeclarators :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.VariableDeclarators +standardEventDeclarationDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationModifiers :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] +standardEventDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationStandardEventDeclaration :: Typed.TypedName Syntax.StandardEventDeclaration +standardEventDeclarationStandardEventDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationType :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.Type +standardEventDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardEventDeclaration +standardEventDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationWithDeclarators :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm Syntax.StandardEventDeclaration +standardEventDeclarationWithDeclarators original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.StandardEventDeclaration +standardEventDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.StandardEventDeclaration +standardEventDeclarationWithType :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.StandardEventDeclaration +standardEventDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarators"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"), + Model.projectionFieldName = (Model.Name "declarators")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.IndexerBody -> Typed.TypedTerm Syntax.StandardIndexerDeclaration +standardIndexerDeclaration attributes modifiers declarator body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm declarator)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +standardIndexerDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationBody :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerBody +standardIndexerDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationDeclarator :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator +standardIndexerDeclarationDeclarator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationModifiers :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] +standardIndexerDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationStandardIndexerDeclaration :: Typed.TypedName Syntax.StandardIndexerDeclaration +standardIndexerDeclarationStandardIndexerDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithBody :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerBody -> Typed.TypedTerm Syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithDeclarator :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithDeclarator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.StandardIndexerDeclaration +standardIndexerDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "declarator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "declarator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclaration :: Typed.TypedTerm [Syntax.LocalFunctionModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.LocalFunctionBody -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclaration modifiers returnType header body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationBody :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionBody +standardLocalFunctionDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationHeader :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader +standardLocalFunctionDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationModifiers :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.LocalFunctionModifier] +standardLocalFunctionDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationReturnType :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.ReturnType +standardLocalFunctionDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationStandardLocalFunctionDeclaration :: Typed.TypedName Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationStandardLocalFunctionDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithBody :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionBody -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithHeader :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.LocalFunctionModifier] -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithReturnType :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration +standardLocalFunctionDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclaration attributes modifiers returnType header body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm returnType)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm header)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationAttributes :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +standardMethodDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationBody :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody +standardMethodDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the header field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationHeader :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader +standardMethodDeclarationHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationModifiers :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier] +standardMethodDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationReturnType :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType +standardMethodDeclarationReturnType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationStandardMethodDeclaration :: Typed.TypedName Syntax.StandardMethodDeclaration +standardMethodDeclarationStandardMethodDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationWithBody :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the header field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclarationWithHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "returnType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.StandardMethodDeclaration +standardMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.StandardMethodDeclaration +standardMethodDeclarationWithReturnType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "returnType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "header"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "header")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.PropertyBody -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclaration attributes modifiers type_ name body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationAttributes :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +standardPropertyDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationBody :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyBody +standardPropertyDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationModifiers :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] +standardPropertyDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationName :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName +standardPropertyDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationStandardPropertyDeclaration :: Typed.TypedName Syntax.StandardPropertyDeclaration +standardPropertyDeclarationStandardPropertyDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationType :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.Type +standardPropertyDeclarationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithBody :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyBody -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithName :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithType :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.StandardPropertyDeclaration +standardPropertyDeclarationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.Statement +statementDeclaration :: Typed.TypedTerm Syntax.DeclarationStatement -> Typed.TypedTerm Syntax.Statement +statementDeclaration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "declaration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the embedded variant of hydra.ext.csharp.syntax.Statement +statementEmbedded :: Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.Statement +statementEmbedded x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "embedded"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionAssignment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "assignment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the await variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionAwait :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionAwait x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "await"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionInvocation :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "invocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.StatementExpressionList wrapper +statementExpressionList :: Typed.TypedTerm [Syntax.StatementExpression] -> Typed.TypedTerm Syntax.StatementExpressionList +statementExpressionList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StatementExpressionList +statementExpressionListStatementExpressionList :: Typed.TypedName Syntax.StatementExpressionList +statementExpressionListStatementExpressionList = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList") + +-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionNullConditionalInvocation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullConditionalInvocation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the objectCreation variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionObjectCreation :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionObjectCreation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "objectCreation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postDecrement variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionPostDecrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionPostDecrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postDecrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the postIncrement variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionPostIncrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionPostIncrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "postIncrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the preDecrement variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionPreDecrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionPreDecrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preDecrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the preIncrement variant of hydra.ext.csharp.syntax.StatementExpression +statementExpressionPreIncrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression +statementExpressionPreIncrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preIncrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StatementExpression +statementExpressionStatementExpression :: Typed.TypedName Syntax.StatementExpression +statementExpressionStatementExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StatementExpression") + +-- | DSL injection for the labeled variant of hydra.ext.csharp.syntax.Statement +statementLabeled :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement +statementLabeled x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "labeled"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.Statement +statementStatement :: Typed.TypedName Syntax.Statement +statementStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Statement") + +-- | DSL injection for the block variant of hydra.ext.csharp.syntax.StaticConstructorBody +staticConstructorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.StaticConstructorBody +staticConstructorBodyBlock x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.StaticConstructorBody +staticConstructorBodyEmpty :: Typed.TypedTerm Syntax.StaticConstructorBody +staticConstructorBodyEmpty = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "empty"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.StaticConstructorBody +staticConstructorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.StaticConstructorBody +staticConstructorBodyExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorBody +staticConstructorBodyStaticConstructorBody :: Typed.TypedName Syntax.StaticConstructorBody +staticConstructorBodyStaticConstructorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody") + +-- | DSL constructor for hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StaticConstructorBody -> Typed.TypedTerm Syntax.StaticConstructorDeclaration +staticConstructorDeclaration attributes modifiers name body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationAttributes :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +staticConstructorDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationBody :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorBody +staticConstructorDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationModifiers :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorModifiers +staticConstructorDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationName :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.Identifier +staticConstructorDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationStaticConstructorDeclaration :: Typed.TypedName Syntax.StaticConstructorDeclaration +staticConstructorDeclarationStaticConstructorDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithAttributes :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithBody :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorBody -> Typed.TypedTerm Syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithName :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StaticConstructorDeclaration +staticConstructorDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiers :: Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers +staticConstructorModifiers extern unsafe = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Typed.unTypedTerm extern)}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Typed.unTypedTerm unsafe)}]})) + +-- | DSL accessor for the extern field of hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiersExtern :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool +staticConstructorModifiersExtern x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiersStaticConstructorModifiers :: Typed.TypedName Syntax.StaticConstructorModifiers +staticConstructorModifiersStaticConstructorModifiers = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers") + +-- | DSL accessor for the unsafe field of hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiersUnsafe :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool +staticConstructorModifiersUnsafe x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the extern field of hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiersWithExtern :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers +staticConstructorModifiersWithExtern original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.projectionFieldName = (Model.Name "unsafe")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unsafe field of hydra.ext.csharp.syntax.StaticConstructorModifiers +staticConstructorModifiersWithUnsafe :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers +staticConstructorModifiersWithUnsafe original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "extern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"), + Model.projectionFieldName = (Model.Name "extern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.StructDeclaration +structDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.StructModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm [Syntax.StructMemberDeclaration] -> Typed.TypedTerm Syntax.StructDeclaration +structDeclaration attributes modifiers ref partial name parameters interfaces constraints body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm modifiers)}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm ref)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm partial)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Typed.unTypedTerm interfaces)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationAttributes :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) +structDeclarationAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationBody :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructMemberDeclaration] +structDeclarationBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationConstraints :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] +structDeclarationConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the interfaces field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationInterfaces :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] +structDeclarationInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationModifiers :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructModifier] +structDeclarationModifiers x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationName :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.Identifier +structDeclarationName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationParameters :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) +structDeclarationParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationPartial :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool +structDeclarationPartial x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ref field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationRef :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool +structDeclarationRef x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.StructDeclaration +structDeclarationStructDeclaration :: Typed.TypedName Syntax.StructDeclaration +structDeclarationStructDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructDeclaration") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithAttributes :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithBody :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructMemberDeclaration] -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithConstraints :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the interfaces field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithInterfaces :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithModifiers :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructModifier] -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithModifiers original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithName :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithParameters :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the partial field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithPartial :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithPartial original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "ref")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ref field of hydra.ext.csharp.syntax.StructDeclaration +structDeclarationWithRef :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StructDeclaration +structDeclarationWithRef original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modifiers"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "modifiers")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ref"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "partial"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "partial")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "interfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "interfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationConstant x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constant"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the constructor variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the event variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationEvent :: Typed.TypedTerm Syntax.EventDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationEvent x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "event"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the field variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationField :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationField x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "field"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the fixedSizeBuffer variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationFixedSizeBuffer :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationFixedSizeBuffer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixedSizeBuffer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationIndexer :: Typed.TypedTerm Syntax.IndexerDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationIndexer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "indexer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the method variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationMethod :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "method"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the operator variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationOperator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationOperator x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the property variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationProperty :: Typed.TypedTerm Syntax.PropertyDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationProperty x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the staticConstructor variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationStaticConstructor :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationStaticConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "staticConstructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationStructMemberDeclaration :: Typed.TypedName Syntax.StructMemberDeclaration +structMemberDeclarationStructMemberDeclaration = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration") + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.StructMemberDeclaration +structMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration +structMemberDeclarationType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.StructModifier +structModifierInternal :: Typed.TypedTerm Syntax.StructModifier +structModifierInternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "internal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the new variant of hydra.ext.csharp.syntax.StructModifier +structModifierNew :: Typed.TypedTerm Syntax.StructModifier +structModifierNew = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the private variant of hydra.ext.csharp.syntax.StructModifier +structModifierPrivate :: Typed.TypedTerm Syntax.StructModifier +structModifierPrivate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "private"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.StructModifier +structModifierProtected :: Typed.TypedTerm Syntax.StructModifier +structModifierProtected = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "protected"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the public variant of hydra.ext.csharp.syntax.StructModifier +structModifierPublic :: Typed.TypedTerm Syntax.StructModifier +structModifierPublic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "public"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the readonly variant of hydra.ext.csharp.syntax.StructModifier +structModifierReadonly :: Typed.TypedTerm Syntax.StructModifier +structModifierReadonly = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "readonly"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StructModifier +structModifierStructModifier :: Typed.TypedName Syntax.StructModifier +structModifierStructModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructModifier") + +-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.StructModifier +structModifierUnsafe :: Typed.TypedTerm Syntax.StructModifier +structModifierUnsafe = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsafe"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the enum variant of hydra.ext.csharp.syntax.StructOrEnumType +structOrEnumTypeEnum :: Typed.TypedTerm Syntax.EnumType -> Typed.TypedTerm Syntax.StructOrEnumType +structOrEnumTypeEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.StructOrEnumType +structOrEnumTypeStruct :: Typed.TypedTerm Syntax.StructType -> Typed.TypedTerm Syntax.StructOrEnumType +structOrEnumTypeStruct x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StructOrEnumType +structOrEnumTypeStructOrEnumType :: Typed.TypedName Syntax.StructOrEnumType +structOrEnumTypeStructOrEnumType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType") + +-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.StructType +structTypeSimple :: Typed.TypedTerm Syntax.SimpleType -> Typed.TypedTerm Syntax.StructType +structTypeSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.StructType +structTypeStructType :: Typed.TypedName Syntax.StructType +structTypeStructType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructType") + +-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.StructType +structTypeTuple :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm Syntax.StructType +structTypeTuple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "tuple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeName variant of hydra.ext.csharp.syntax.StructType +structTypeTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.StructType +structTypeTypeName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.SwitchBranch +switchBranch :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SwitchBranch +switchBranch pattern guard = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm pattern)}, + Model.Field { + Model.fieldName = (Model.Name "guard"), + Model.fieldTerm = (Typed.unTypedTerm guard)}]})) + +-- | DSL accessor for the guard field of hydra.ext.csharp.syntax.SwitchBranch +switchBranchGuard :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm (Maybe Syntax.Expression) +switchBranchGuard x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.projectionFieldName = (Model.Name "guard")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pattern field of hydra.ext.csharp.syntax.SwitchBranch +switchBranchPattern :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.Pattern +switchBranchPattern x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SwitchBranch +switchBranchSwitchBranch :: Typed.TypedName Syntax.SwitchBranch +switchBranchSwitchBranch = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchBranch") + +-- | DSL updater for the guard field of hydra.ext.csharp.syntax.SwitchBranch +switchBranchWithGuard :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SwitchBranch +switchBranchWithGuard original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "guard"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the pattern field of hydra.ext.csharp.syntax.SwitchBranch +switchBranchWithPattern :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.SwitchBranch +switchBranchWithPattern original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "guard"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"), + Model.projectionFieldName = (Model.Name "guard")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the branch variant of hydra.ext.csharp.syntax.SwitchLabel +switchLabelBranch :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.SwitchLabel +switchLabelBranch x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchLabel"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the default variant of hydra.ext.csharp.syntax.SwitchLabel +switchLabelDefault :: Typed.TypedTerm Syntax.SwitchLabel +switchLabelDefault = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchLabel"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.SwitchLabel +switchLabelSwitchLabel :: Typed.TypedName Syntax.SwitchLabel +switchLabelSwitchLabel = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchLabel") + +-- | DSL constructor for hydra.ext.csharp.syntax.SwitchSection +switchSection :: Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.SwitchSection +switchSection labels statements = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "labels"), + Model.fieldTerm = (Typed.unTypedTerm labels)}, + Model.Field { + Model.fieldName = (Model.Name "statements"), + Model.fieldTerm = (Typed.unTypedTerm statements)}]})) + +-- | DSL accessor for the labels field of hydra.ext.csharp.syntax.SwitchSection +switchSectionLabels :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.SwitchLabel] +switchSectionLabels x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.projectionFieldName = (Model.Name "labels")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the statements field of hydra.ext.csharp.syntax.SwitchSection +switchSectionStatements :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.Statement] +switchSectionStatements x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.projectionFieldName = (Model.Name "statements")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SwitchSection +switchSectionSwitchSection :: Typed.TypedName Syntax.SwitchSection +switchSectionSwitchSection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchSection") + +-- | DSL updater for the labels field of hydra.ext.csharp.syntax.SwitchSection +switchSectionWithLabels :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm Syntax.SwitchSection +switchSectionWithLabels original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "labels"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.projectionFieldName = (Model.Name "statements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statements field of hydra.ext.csharp.syntax.SwitchSection +switchSectionWithStatements :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.SwitchSection +switchSectionWithStatements original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "labels"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"), + Model.projectionFieldName = (Model.Name "labels")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statements"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.SwitchStatement +switchStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.SwitchSection] -> Typed.TypedTerm Syntax.SwitchStatement +switchStatement expression branches = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "branches"), + Model.fieldTerm = (Typed.unTypedTerm branches)}]})) + +-- | DSL accessor for the branches field of hydra.ext.csharp.syntax.SwitchStatement +switchStatementBranches :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.SwitchSection] +switchStatementBranches x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "branches")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.SwitchStatement +switchStatementExpression :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression +switchStatementExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.SwitchStatement +switchStatementSwitchStatement :: Typed.TypedName Syntax.SwitchStatement +switchStatementSwitchStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchStatement") + +-- | DSL updater for the branches field of hydra.ext.csharp.syntax.SwitchStatement +switchStatementWithBranches :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.SwitchSection] -> Typed.TypedTerm Syntax.SwitchStatement +switchStatementWithBranches original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "branches"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.SwitchStatement +switchStatementWithExpression :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchStatement +switchStatementWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "branches"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"), + Model.projectionFieldName = (Model.Name "branches")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.TryStatement +tryStatement :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClauses -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryStatement +tryStatement body catches finally = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}, + Model.Field { + Model.fieldName = (Model.Name "catches"), + Model.fieldTerm = (Typed.unTypedTerm catches)}, + Model.Field { + Model.fieldName = (Model.Name "finally"), + Model.fieldTerm = (Typed.unTypedTerm finally)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.TryStatement +tryStatementBody :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.Block +tryStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the catches field of hydra.ext.csharp.syntax.TryStatement +tryStatementCatches :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.CatchClauses +tryStatementCatches x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "catches")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the finally field of hydra.ext.csharp.syntax.TryStatement +tryStatementFinally :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm (Maybe Syntax.Block) +tryStatementFinally x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "finally")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TryStatement +tryStatementTryStatement :: Typed.TypedName Syntax.TryStatement +tryStatementTryStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TryStatement") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.TryStatement +tryStatementWithBody :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryStatement +tryStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "catches"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "catches")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "finally"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "finally")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the catches field of hydra.ext.csharp.syntax.TryStatement +tryStatementWithCatches :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.CatchClauses -> Typed.TypedTerm Syntax.TryStatement +tryStatementWithCatches original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "catches"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "finally"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "finally")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the finally field of hydra.ext.csharp.syntax.TryStatement +tryStatementWithFinally :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryStatement +tryStatementWithFinally original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "catches"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"), + Model.projectionFieldName = (Model.Name "catches")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "finally"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.TupleElement +tupleElement :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TupleElement +tupleElement name expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.TupleElement +tupleElementExpression :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm Syntax.Expression +tupleElementExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.TupleElement +tupleElementName :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm (Maybe Syntax.Identifier) +tupleElementName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TupleElement +tupleElementTupleElement :: Typed.TypedName Syntax.TupleElement +tupleElementTupleElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleElement") + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.TupleElement +tupleElementWithExpression :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TupleElement +tupleElementWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.TupleElement +tupleElementWithName :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleElement +tupleElementWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the deconstruction variant of hydra.ext.csharp.syntax.TupleExpression +tupleExpressionDeconstruction :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm Syntax.TupleExpression +tupleExpressionDeconstruction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "deconstruction"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the elements variant of hydra.ext.csharp.syntax.TupleExpression +tupleExpressionElements :: Typed.TypedTerm [Syntax.TupleElement] -> Typed.TypedTerm Syntax.TupleExpression +tupleExpressionElements x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.TupleExpression +tupleExpressionTupleExpression :: Typed.TypedName Syntax.TupleExpression +tupleExpressionTupleExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleExpression") + +-- | DSL constructor for the hydra.ext.csharp.syntax.TupleType wrapper +tupleType :: Typed.TypedTerm [Syntax.TupleTypeElement] -> Typed.TypedTerm Syntax.TupleType +tupleType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElement :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleTypeElement +tupleTypeElement type_ identifier = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElementIdentifier :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm (Maybe Syntax.Identifier) +tupleTypeElementIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElementTupleTypeElement :: Typed.TypedName Syntax.TupleTypeElement +tupleTypeElementTupleTypeElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement") + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElementType :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm Syntax.Type +tupleTypeElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElementWithIdentifier :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleTypeElement +tupleTypeElementWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.TupleTypeElement +tupleTypeElementWithType :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TupleTypeElement +tupleTypeElementWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.TupleType +tupleTypeTupleType :: Typed.TypedName Syntax.TupleType +tupleTypeTupleType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleType") + +-- | DSL constructor for the hydra.ext.csharp.syntax.TypeArgumentList wrapper +typeArgumentList :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TypeArgumentList +typeArgumentList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeArgumentList +typeArgumentListTypeArgumentList :: Typed.TypedName Syntax.TypeArgumentList +typeArgumentListTypeArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList") + +-- | DSL injection for the class variant of hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration +typeDeclarationClass x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "class"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationDelegate :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration +typeDeclarationDelegate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "delegate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationEnum :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration +typeDeclarationEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration +typeDeclarationInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationStruct :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration +typeDeclarationStruct x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeDeclaration +typeDeclarationTypeDeclaration :: Typed.TypedName Syntax.TypeDeclaration +typeDeclarationTypeDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration") + +-- | DSL constructor for the hydra.ext.csharp.syntax.TypeName wrapper +typeName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.TypeName +typeName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeName +typeNameTypeName :: Typed.TypedName Syntax.TypeName +typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeName") + +-- | DSL injection for the param variant of hydra.ext.csharp.syntax.Type +typeParam :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.Type +typeParam x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "param"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.TypeParameter wrapper +typeParameter :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.TypeParameter +typeParameter x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameter"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraints :: Typed.TypedTerm (Maybe Syntax.PrimaryConstraint) -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeParameterConstraints +typeParameterConstraints primary secondary constructor = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Typed.unTypedTerm primary)}, + Model.Field { + Model.fieldName = (Model.Name "secondary"), + Model.fieldTerm = (Typed.unTypedTerm secondary)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm constructor)}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClause :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm [Syntax.TypeParameterConstraints] -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause +typeParameterConstraintsClause parameter constraints = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm parameter)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}]})) + +-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseConstraints :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm [Syntax.TypeParameterConstraints] +typeParameterConstraintsClauseConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseParameter :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm Syntax.TypeParameter +typeParameterConstraintsClauseParameter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseTypeParameterConstraintsClause :: Typed.TypedName Syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseTypeParameterConstraintsClause = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause") + +-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseWithConstraints :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm [Syntax.TypeParameterConstraints] -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseWithParameter :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause +typeParameterConstraintsClauseWithParameter original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the constructor field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsConstructor :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm Bool +typeParameterConstraintsConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the primary field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsPrimary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.PrimaryConstraint) +typeParameterConstraintsPrimary x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "primary")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the secondary field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsSecondary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints) +typeParameterConstraintsSecondary x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "secondary")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsTypeParameterConstraints :: Typed.TypedName Syntax.TypeParameterConstraints +typeParameterConstraintsTypeParameterConstraints = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints") + +-- | DSL updater for the constructor field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsWithConstructor :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeParameterConstraints +typeParameterConstraintsWithConstructor original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "primary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "secondary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "secondary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the primary field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsWithPrimary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.PrimaryConstraint) -> Typed.TypedTerm Syntax.TypeParameterConstraints +typeParameterConstraintsWithPrimary original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "secondary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "secondary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the secondary field of hydra.ext.csharp.syntax.TypeParameterConstraints +typeParameterConstraintsWithSecondary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints) -> Typed.TypedTerm Syntax.TypeParameterConstraints +typeParameterConstraintsWithSecondary original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "primary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "secondary"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"), + Model.projectionFieldName = (Model.Name "constructor")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.TypeParameterList wrapper +typeParameterList :: Typed.TypedTerm [Syntax.TypeParameterPart] -> Typed.TypedTerm Syntax.TypeParameterList +typeParameterList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterList +typeParameterListTypeParameterList :: Typed.TypedName Syntax.TypeParameterList +typeParameterListTypeParameterList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterList") + +-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPart :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterPart +typeParameterPart attributes name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPartAttributes :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm (Maybe Syntax.Attributes) +typeParameterPartAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPartName :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm Syntax.TypeParameter +typeParameterPartName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPartTypeParameterPart :: Typed.TypedName Syntax.TypeParameterPart +typeParameterPartTypeParameterPart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPartWithAttributes :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.TypeParameterPart +typeParameterPartWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.TypeParameterPart +typeParameterPartWithName :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterPart +typeParameterPartWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeParameter +typeParameterTypeParameter :: Typed.TypedName Syntax.TypeParameter +typeParameterTypeParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameter") + +-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.Type +typePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.Type +typePointer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the reference variant of hydra.ext.csharp.syntax.Type +typeReference :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.Type +typeReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.Type +typeType :: Typed.TypedName Syntax.Type +typeType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Type") + +-- | DSL injection for the value variant of hydra.ext.csharp.syntax.Type +typeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.Type +typeValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.csharp.syntax.TypeofExpression +typeofExpressionType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeofExpression +typeofExpressionType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.TypeofExpression +typeofExpressionTypeofExpression :: Typed.TypedName Syntax.TypeofExpression +typeofExpressionTypeofExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeofExpression") + +-- | DSL injection for the unboundTypeName variant of hydra.ext.csharp.syntax.TypeofExpression +typeofExpressionUnboundTypeName :: Typed.TypedTerm Syntax.UnboundTypeName -> Typed.TypedTerm Syntax.TypeofExpression +typeofExpressionUnboundTypeName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unboundTypeName"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the void variant of hydra.ext.csharp.syntax.TypeofExpression +typeofExpressionVoid :: Typed.TypedTerm Syntax.TypeofExpression +typeofExpressionVoid = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "void"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ArgumentList +unArgumentList :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm [Syntax.Argument] +unArgumentList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ArgumentList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ArrayInitializer +unArrayInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm [Syntax.VariableInitializer] +unArrayInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeArgumentExpression +unAttributeArgumentExpression :: Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression +unAttributeArgumentExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeList +unAttributeList :: Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm [Syntax.Attribute] +unAttributeList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeName +unAttributeName :: Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm Syntax.TypeName +unAttributeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.Attributes +unAttributes :: Typed.TypedTerm Syntax.Attributes -> Typed.TypedTerm [Syntax.AttributeSection] +unAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Attributes")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.Block +unBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.Statement] +unBlock x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Block")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.BooleanExpression +unBooleanExpression :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.Expression +unBooleanExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.BooleanExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ClassBody +unClassBody :: Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm [Syntax.ClassMemberDeclaration] +unClassBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ClassBody")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ConstantExpression +unConstantExpression :: Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.Expression +unConstantExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ConstantExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.DeconstructionTuple +unDeconstructionTuple :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm [Syntax.DeconstructionElement] +unDeconstructionTuple x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.DelegateType +unDelegateType :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.TypeName +unDelegateType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.DelegateType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.Designation +unDesignation :: Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.Identifier +unDesignation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Designation")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.EnumBody +unEnumBody :: Typed.TypedTerm Syntax.EnumBody -> Typed.TypedTerm [Syntax.EnumMemberDeclaration] +unEnumBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.EnumBody")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.EnumType +unEnumType :: Typed.TypedTerm Syntax.EnumType -> Typed.TypedTerm Syntax.TypeName +unEnumType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.EnumType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ExpressionList +unExpressionList :: Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm [Syntax.Expression] +unExpressionList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ExpressionList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.ExternAliasDirective +unExternAliasDirective :: Typed.TypedTerm Syntax.ExternAliasDirective -> Typed.TypedTerm Syntax.Identifier +unExternAliasDirective x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.Identifier +unIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm String +unIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Identifier")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterfaceType +unInterfaceType :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.TypeName +unInterfaceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterfaceType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterpolatedRegularStringExpression +unInterpolatedRegularStringExpression :: Typed.TypedTerm Syntax.InterpolatedRegularStringExpression -> Typed.TypedTerm String +unInterpolatedRegularStringExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression +unInterpolatedVerbatimStringExpression :: Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression -> Typed.TypedTerm String +unInterpolatedVerbatimStringExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.Keyword +unKeyword :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String +unKeyword x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Keyword")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.MemberDeclaratorList +unMemberDeclaratorList :: Typed.TypedTerm Syntax.MemberDeclaratorList -> Typed.TypedTerm [Syntax.MemberDeclarator] +unMemberDeclaratorList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.NamedArgumentList +unNamedArgumentList :: Typed.TypedTerm Syntax.NamedArgumentList -> Typed.TypedTerm [Syntax.NamedArgument] +unNamedArgumentList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.NamespaceName +unNamespaceName :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.NamespaceOrTypeName +unNamespaceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.NamespaceName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.PositionalArgumentList +unPositionalArgumentList :: Typed.TypedTerm Syntax.PositionalArgumentList -> Typed.TypedTerm [Syntax.PositionalArgument] +unPositionalArgumentList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.QualifiedIdentifier +unQualifiedIdentifier :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm [Syntax.Identifier] +unQualifiedIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.RankSpecifier +unRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Int +unRankSpecifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.RankSpecifier")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.SecondaryConstraints +unSecondaryConstraints :: Typed.TypedTerm Syntax.SecondaryConstraints -> Typed.TypedTerm [Syntax.SecondaryConstraint] +unSecondaryConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.StatementExpressionList +unStatementExpressionList :: Typed.TypedTerm Syntax.StatementExpressionList -> Typed.TypedTerm [Syntax.StatementExpression] +unStatementExpressionList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.TupleType +unTupleType :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.TupleTypeElement] +unTupleType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TupleType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeArgumentList +unTypeArgumentList :: Typed.TypedTerm Syntax.TypeArgumentList -> Typed.TypedTerm [Syntax.Type] +unTypeArgumentList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeName +unTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName +unTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeParameter +unTypeParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.Identifier +unTypeParameter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeParameter")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeParameterList +unTypeParameterList :: Typed.TypedTerm Syntax.TypeParameterList -> Typed.TypedTerm [Syntax.TypeParameterPart] +unTypeParameterList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeParameterList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.UnboundTypeName +unUnboundTypeName :: Typed.TypedTerm Syntax.UnboundTypeName -> Typed.TypedTerm [Syntax.UnboundTypeNamePart] +unUnboundTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariableDeclarators +unVariableDeclarators :: Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm [Syntax.VariableDeclarator] +unVariableDeclarators x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariableReference +unVariableReference :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.Expression +unVariableReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariableReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariantTypeParameters +unVariantTypeParameters :: Typed.TypedTerm Syntax.VariantTypeParameters -> Typed.TypedTerm [Syntax.VariantTypeParameter] +unVariantTypeParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the addressOf variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionAddressOf :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionAddressOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "addressOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the await variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionAwait :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionAwait x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "await"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the bitwiseComplement variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionBitwiseComplement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionBitwiseComplement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitwiseComplement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the cast variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionCast :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionCast x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "cast"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionMinus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionMinus x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the not variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionNot :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionNot x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionPlus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPlus x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pointerIndirection variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionPointerIndirection :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPointerIndirection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointerIndirection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the preDecrement variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionPreDecrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPreDecrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preDecrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the preIncrement variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionPreIncrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPreIncrement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preIncrement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the primary variant of hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.UnaryExpression +unaryExpressionPrimary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.UnaryExpression +unaryExpressionUnaryExpression :: Typed.TypedName Syntax.UnaryExpression +unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnaryExpression") + +-- | DSL constructor for hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OverloadableUnaryOperator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator +unaryOperatorDeclarator type_ operator parameter = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm parameter)}]})) + +-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorOperator :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableUnaryOperator +unaryOperatorDeclaratorOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorParameter :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter +unaryOperatorDeclaratorParameter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorType :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type +unaryOperatorDeclaratorType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorUnaryOperatorDeclarator :: Typed.TypedName Syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorUnaryOperatorDeclarator = + Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator") + +-- | DSL updater for the operator field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithOperator :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableUnaryOperator -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithParameter :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithParameter original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator +unaryOperatorDeclaratorWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.UnboundTypeName wrapper +unboundTypeName :: Typed.TypedTerm [Syntax.UnboundTypeNamePart] -> Typed.TypedTerm Syntax.UnboundTypeName +unboundTypeName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePart :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Syntax.UnboundTypeNamePart +unboundTypeNamePart identifier aliased dimension = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "aliased"), + Model.fieldTerm = (Typed.unTypedTerm aliased)}, + Model.Field { + Model.fieldName = (Model.Name "dimension"), + Model.fieldTerm = (Typed.unTypedTerm dimension)}]})) + +-- | DSL accessor for the aliased field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartAliased :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Bool +unboundTypeNamePartAliased x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "aliased")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dimension field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartDimension :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm (Maybe Int) +unboundTypeNamePartDimension x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "dimension")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartIdentifier :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Syntax.Identifier +unboundTypeNamePartIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartUnboundTypeNamePart :: Typed.TypedName Syntax.UnboundTypeNamePart +unboundTypeNamePartUnboundTypeNamePart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart") + +-- | DSL updater for the aliased field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartWithAliased :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.UnboundTypeNamePart +unboundTypeNamePartWithAliased original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliased"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dimension"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "dimension")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dimension field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartWithDimension :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Syntax.UnboundTypeNamePart +unboundTypeNamePartWithDimension original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliased"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "aliased")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dimension"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.UnboundTypeNamePart +unboundTypeNamePartWithIdentifier :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.UnboundTypeNamePart +unboundTypeNamePartWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aliased"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "aliased")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dimension"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"), + Model.projectionFieldName = (Model.Name "dimension")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.csharp.syntax.UnboundTypeName +unboundTypeNameUnboundTypeName :: Typed.TypedName Syntax.UnboundTypeName +unboundTypeNameUnboundTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName") + +-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.UnmanagedType +unmanagedTypePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.UnmanagedType +unmanagedTypePointer x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnmanagedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pointer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.UnmanagedType +unmanagedTypeUnmanagedType :: Typed.TypedName Syntax.UnmanagedType +unmanagedTypeUnmanagedType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnmanagedType") + +-- | DSL injection for the value variant of hydra.ext.csharp.syntax.UnmanagedType +unmanagedTypeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.UnmanagedType +unmanagedTypeValue x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnmanagedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirective :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.UsingAliasDirective +usingAliasDirective alias name = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}]})) + +-- | DSL accessor for the alias field of hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirectiveAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.Identifier +usingAliasDirectiveAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirectiveName :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.NamespaceOrTypeName +usingAliasDirectiveName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirectiveUsingAliasDirective :: Typed.TypedName Syntax.UsingAliasDirective +usingAliasDirectiveUsingAliasDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective") + +-- | DSL updater for the alias field of hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirectiveWithAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.UsingAliasDirective +usingAliasDirectiveWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.csharp.syntax.UsingAliasDirective +usingAliasDirectiveWithName :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.UsingAliasDirective +usingAliasDirectiveWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the alias variant of hydra.ext.csharp.syntax.UsingDirective +usingDirectiveAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.UsingDirective +usingDirectiveAlias x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the namespace variant of hydra.ext.csharp.syntax.UsingDirective +usingDirectiveNamespace :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.UsingDirective +usingDirectiveNamespace x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the static variant of hydra.ext.csharp.syntax.UsingDirective +usingDirectiveStatic :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.UsingDirective +usingDirectiveStatic x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "static"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.UsingDirective +usingDirectiveUsingDirective :: Typed.TypedName Syntax.UsingDirective +usingDirectiveUsingDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingDirective") + +-- | DSL constructor for hydra.ext.csharp.syntax.UsingStatement +usingStatement :: Typed.TypedTerm Syntax.ResourceAcquisition -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.UsingStatement +usingStatement acquisition body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "acquisition"), + Model.fieldTerm = (Typed.unTypedTerm acquisition)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the acquisition field of hydra.ext.csharp.syntax.UsingStatement +usingStatementAcquisition :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.ResourceAcquisition +usingStatementAcquisition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.projectionFieldName = (Model.Name "acquisition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.UsingStatement +usingStatementBody :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +usingStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.UsingStatement +usingStatementUsingStatement :: Typed.TypedName Syntax.UsingStatement +usingStatementUsingStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingStatement") + +-- | DSL updater for the acquisition field of hydra.ext.csharp.syntax.UsingStatement +usingStatementWithAcquisition :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.ResourceAcquisition -> Typed.TypedTerm Syntax.UsingStatement +usingStatementWithAcquisition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "acquisition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.UsingStatement +usingStatementWithBody :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.UsingStatement +usingStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "acquisition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"), + Model.projectionFieldName = (Model.Name "acquisition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the nonNullable variant of hydra.ext.csharp.syntax.ValueType +valueTypeNonNullable :: Typed.TypedTerm Syntax.StructOrEnumType -> Typed.TypedTerm Syntax.ValueType +valueTypeNonNullable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ValueType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nonNullable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nullable variant of hydra.ext.csharp.syntax.ValueType +valueTypeNullable :: Typed.TypedTerm Syntax.StructOrEnumType -> Typed.TypedTerm Syntax.ValueType +valueTypeNullable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ValueType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nullable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.ValueType +valueTypeValueType :: Typed.TypedName Syntax.ValueType +valueTypeValueType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ValueType") + +-- | DSL constructor for hydra.ext.csharp.syntax.VariableDeclarator +variableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator +variableDeclarator identifier initializer = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm identifier)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm initializer)}]})) + +-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.VariableDeclarator +variableDeclaratorIdentifier :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.Identifier +variableDeclaratorIdentifier x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.VariableDeclarator +variableDeclaratorInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) +variableDeclaratorInitializer x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariableDeclarator +variableDeclaratorVariableDeclarator :: Typed.TypedName Syntax.VariableDeclarator +variableDeclaratorVariableDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator") + +-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.VariableDeclarator +variableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableDeclarator +variableDeclaratorWithIdentifier original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.projectionFieldName = (Model.Name "initializer")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.VariableDeclarator +variableDeclaratorWithInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator +variableDeclaratorWithInitializer original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "identifier"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"), + Model.projectionFieldName = (Model.Name "identifier")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "initializer"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.VariableDeclarators wrapper +variableDeclarators :: Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.VariableDeclarators +variableDeclarators x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariableDeclarators +variableDeclaratorsVariableDeclarators :: Typed.TypedName Syntax.VariableDeclarators +variableDeclaratorsVariableDeclarators = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators") + +-- | DSL injection for the array variant of hydra.ext.csharp.syntax.VariableInitializer +variableInitializerArray :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.VariableInitializer +variableInitializerArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.VariableInitializer +variableInitializerExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableInitializer +variableInitializerExpression x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableInitializer"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariableInitializer +variableInitializerVariableInitializer :: Typed.TypedName Syntax.VariableInitializer +variableInitializerVariableInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableInitializer") + +-- | DSL constructor for the hydra.ext.csharp.syntax.VariableReference wrapper +variableReference :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableReference +variableReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariableReference +variableReferenceVariableReference :: Typed.TypedName Syntax.VariableReference +variableReferenceVariableReference = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableReference") + +-- | DSL injection for the in variant of hydra.ext.csharp.syntax.VarianceAnnotation +varianceAnnotationIn :: Typed.TypedTerm Syntax.VarianceAnnotation +varianceAnnotationIn = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "in"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the out variant of hydra.ext.csharp.syntax.VarianceAnnotation +varianceAnnotationOut :: Typed.TypedTerm Syntax.VarianceAnnotation +varianceAnnotationOut = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "out"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.csharp.syntax.VarianceAnnotation +varianceAnnotationVarianceAnnotation :: Typed.TypedName Syntax.VarianceAnnotation +varianceAnnotationVarianceAnnotation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation") + +-- | DSL constructor for hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameter :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation) -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.VariantTypeParameter +variantTypeParameter attributes variance parameter = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm attributes)}, + Model.Field { + Model.fieldName = (Model.Name "variance"), + Model.fieldTerm = (Typed.unTypedTerm variance)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm parameter)}]})) + +-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterAttributes :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) +variantTypeParameterAttributes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterParameter :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm Syntax.TypeParameter +variantTypeParameterParameter x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the variance field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterVariance :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation) +variantTypeParameterVariance x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "variance")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterVariantTypeParameter :: Typed.TypedName Syntax.VariantTypeParameter +variantTypeParameterVariantTypeParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter") + +-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterWithAttributes :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.VariantTypeParameter +variantTypeParameterWithAttributes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "variance"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "variance")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterWithParameter :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.VariantTypeParameter +variantTypeParameterWithParameter original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variance"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "variance")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the variance field of hydra.ext.csharp.syntax.VariantTypeParameter +variantTypeParameterWithVariance :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation) -> Typed.TypedTerm Syntax.VariantTypeParameter +variantTypeParameterWithVariance original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "attributes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "attributes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "variance"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "parameter"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"), + Model.projectionFieldName = (Model.Name "parameter")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.csharp.syntax.VariantTypeParameters wrapper +variantTypeParameters :: Typed.TypedTerm [Syntax.VariantTypeParameter] -> Typed.TypedTerm Syntax.VariantTypeParameters +variantTypeParameters x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VariantTypeParameters +variantTypeParametersVariantTypeParameters :: Typed.TypedName Syntax.VariantTypeParameters +variantTypeParametersVariantTypeParameters = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters") + +-- | DSL constructor for hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.VerbatimInterpolation +verbatimInterpolation expression width format = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Typed.unTypedTerm width)}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Typed.unTypedTerm format)}]})) + +-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationExpression :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm Syntax.Expression +verbatimInterpolationExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the format field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationFormat :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe String) +verbatimInterpolationFormat x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationVerbatimInterpolation :: Typed.TypedName Syntax.VerbatimInterpolation +verbatimInterpolationVerbatimInterpolation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation") + +-- | DSL accessor for the width field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationWidth :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) +verbatimInterpolationWidth x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationWithExpression :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VerbatimInterpolation +verbatimInterpolationWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the format field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationWithFormat :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.VerbatimInterpolation +verbatimInterpolationWithFormat original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "width")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the width field of hydra.ext.csharp.syntax.VerbatimInterpolation +verbatimInterpolationWithWidth :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.VerbatimInterpolation +verbatimInterpolationWithWidth original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "width"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "format"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"), + Model.projectionFieldName = (Model.Name "format")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.csharp.syntax.WhileStatement +whileStatement :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.WhileStatement +whileStatement condition body = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm condition)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm body)}]})) + +-- | DSL accessor for the body field of hydra.ext.csharp.syntax.WhileStatement +whileStatementBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.EmbeddedStatement +whileStatementBody x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.WhileStatement +whileStatementCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.BooleanExpression +whileStatementCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.csharp.syntax.WhileStatement +whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement +whileStatementWhileStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.WhileStatement") + +-- | DSL updater for the body field of hydra.ext.csharp.syntax.WhileStatement +whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.WhileStatement +whileStatementWithBody original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "condition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the condition field of hydra.ext.csharp.syntax.WhileStatement +whileStatementWithCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.WhileStatement +whileStatementWithCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "condition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "body"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"), + Model.projectionFieldName = (Model.Name "body")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the break variant of hydra.ext.csharp.syntax.YieldStatement +yieldStatementBreak :: Typed.TypedTerm Syntax.YieldStatement +yieldStatementBreak = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.YieldStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "break"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the return variant of hydra.ext.csharp.syntax.YieldStatement +yieldStatementReturn :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.YieldStatement +yieldStatementReturn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.YieldStatement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "return"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.csharp.syntax.YieldStatement +yieldStatementYieldStatement :: Typed.TypedName Syntax.YieldStatement +yieldStatementYieldStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.YieldStatement") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Datalog/Syntax.hs b/src/main/haskell/Hydra/Ext/Dsl/Datalog/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Datalog/Syntax.hs @@ -0,0 +1,608 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.datalog.syntax + +module Hydra.Ext.Dsl.Datalog.Syntax where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Datalog.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.datalog.syntax.Atom +atom :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.Atom +atom relation termList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Typed.unTypedTerm relation)}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Typed.unTypedTerm termList)}]})) + +-- | DSL name token for hydra.ext.datalog.syntax.Atom +atomAtom :: Typed.TypedName Syntax.Atom +atomAtom = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Atom") + +-- | DSL name token for hydra.ext.datalog.syntax.AtomList +atomListAtomList :: Typed.TypedName Syntax.AtomList +atomListAtomList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.AtomList") + +-- | DSL injection for the many variant of hydra.ext.datalog.syntax.AtomList +atomListMany :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList +atomListMany x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "many"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.datalog.syntax.AtomListMultiple +atomListMultiple :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.AtomListMultiple +atomListMultiple atom atomList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Typed.unTypedTerm atom)}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Typed.unTypedTerm atomList)}]})) + +-- | DSL accessor for the Atom field of hydra.ext.datalog.syntax.AtomListMultiple +atomListMultipleAtom :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.Atom +atomListMultipleAtom x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.projectionFieldName = (Model.Name "Atom")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the AtomList field of hydra.ext.datalog.syntax.AtomListMultiple +atomListMultipleAtomList :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList +atomListMultipleAtomList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.projectionFieldName = (Model.Name "AtomList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.AtomListMultiple +atomListMultipleAtomListMultiple :: Typed.TypedName Syntax.AtomListMultiple +atomListMultipleAtomListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple") + +-- | DSL updater for the Atom field of hydra.ext.datalog.syntax.AtomListMultiple +atomListMultipleWithAtom :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomListMultiple +atomListMultipleWithAtom original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.projectionFieldName = (Model.Name "AtomList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the AtomList field of hydra.ext.datalog.syntax.AtomListMultiple +atomListMultipleWithAtomList :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.AtomListMultiple +atomListMultipleWithAtomList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"), + Model.projectionFieldName = (Model.Name "Atom")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the single variant of hydra.ext.datalog.syntax.AtomList +atomListSingle :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList +atomListSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the Relation field of hydra.ext.datalog.syntax.Atom +atomRelation :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Relation +atomRelation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.projectionFieldName = (Model.Name "Relation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the TermList field of hydra.ext.datalog.syntax.Atom +atomTermList :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.TermList +atomTermList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.projectionFieldName = (Model.Name "TermList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Relation field of hydra.ext.datalog.syntax.Atom +atomWithRelation :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.Atom +atomWithRelation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.projectionFieldName = (Model.Name "TermList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the TermList field of hydra.ext.datalog.syntax.Atom +atomWithTermList :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.Atom +atomWithTermList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"), + Model.projectionFieldName = (Model.Name "Relation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.datalog.syntax.Constant wrapper +constant :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Constant +constant x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Constant"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.Constant +constantConstant :: Typed.TypedName Syntax.Constant +constantConstant = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Constant") + +-- | DSL name token for hydra.ext.datalog.syntax.ConstantList +constantListConstantList :: Typed.TypedName Syntax.ConstantList +constantListConstantList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ConstantList") + +-- | DSL injection for the many variant of hydra.ext.datalog.syntax.ConstantList +constantListMany :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList +constantListMany x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "many"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultiple :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.ConstantListMultiple +constantListMultiple constant constantList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Constant"), + Model.fieldTerm = (Typed.unTypedTerm constant)}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Typed.unTypedTerm constantList)}]})) + +-- | DSL accessor for the Constant field of hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultipleConstant :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.Constant +constantListMultipleConstant x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.projectionFieldName = (Model.Name "Constant")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ConstantList field of hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultipleConstantList :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList +constantListMultipleConstantList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.projectionFieldName = (Model.Name "ConstantList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultipleConstantListMultiple :: Typed.TypedName Syntax.ConstantListMultiple +constantListMultipleConstantListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple") + +-- | DSL updater for the Constant field of hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultipleWithConstant :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantListMultiple +constantListMultipleWithConstant original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Constant"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.projectionFieldName = (Model.Name "ConstantList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ConstantList field of hydra.ext.datalog.syntax.ConstantListMultiple +constantListMultipleWithConstantList :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.ConstantListMultiple +constantListMultipleWithConstantList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Constant"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"), + Model.projectionFieldName = (Model.Name "Constant")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the single variant of hydra.ext.datalog.syntax.ConstantList +constantListSingle :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantList +constantListSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.datalog.syntax.Fact +fact :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.Fact +fact relation constantList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Typed.unTypedTerm relation)}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Typed.unTypedTerm constantList)}]})) + +-- | DSL accessor for the ConstantList field of hydra.ext.datalog.syntax.Fact +factConstantList :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ConstantList +factConstantList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.projectionFieldName = (Model.Name "ConstantList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.Fact +factFact :: Typed.TypedName Syntax.Fact +factFact = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Fact") + +-- | DSL accessor for the Relation field of hydra.ext.datalog.syntax.Fact +factRelation :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.Relation +factRelation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.projectionFieldName = (Model.Name "Relation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ConstantList field of hydra.ext.datalog.syntax.Fact +factWithConstantList :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.Fact +factWithConstantList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.projectionFieldName = (Model.Name "Relation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Relation field of hydra.ext.datalog.syntax.Fact +factWithRelation :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.Fact +factWithRelation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Relation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ConstantList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"), + Model.projectionFieldName = (Model.Name "ConstantList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.datalog.syntax.Program wrapper +program :: Typed.TypedTerm [Syntax.ProgramElmt] -> Typed.TypedTerm Syntax.Program +program x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Program"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL injection for the Fact variant of hydra.ext.datalog.syntax.ProgramElmt +programElmtFact :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ProgramElmt +programElmtFact x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ProgramElmt"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Fact"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.datalog.syntax.ProgramElmt +programElmtProgramElmt :: Typed.TypedName Syntax.ProgramElmt +programElmtProgramElmt = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ProgramElmt") + +-- | DSL injection for the Rule variant of hydra.ext.datalog.syntax.ProgramElmt +programElmtRule :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.ProgramElmt +programElmtRule x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ProgramElmt"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Rule"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.datalog.syntax.Program +programProgram :: Typed.TypedName Syntax.Program +programProgram = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Program") + +-- | DSL constructor for the hydra.ext.datalog.syntax.Relation wrapper +relation :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Relation +relation x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Relation"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.Relation +relationRelation :: Typed.TypedName Syntax.Relation +relationRelation = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Relation") + +-- | DSL constructor for hydra.ext.datalog.syntax.Rule +rule :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.Rule +rule atom atomList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Typed.unTypedTerm atom)}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Typed.unTypedTerm atomList)}]})) + +-- | DSL accessor for the Atom field of hydra.ext.datalog.syntax.Rule +ruleAtom :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.Atom +ruleAtom x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.projectionFieldName = (Model.Name "Atom")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the AtomList field of hydra.ext.datalog.syntax.Rule +ruleAtomList :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.AtomList +ruleAtomList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.projectionFieldName = (Model.Name "AtomList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.Rule +ruleRule :: Typed.TypedName Syntax.Rule +ruleRule = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Rule") + +-- | DSL updater for the Atom field of hydra.ext.datalog.syntax.Rule +ruleWithAtom :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Rule +ruleWithAtom original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.projectionFieldName = (Model.Name "AtomList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the AtomList field of hydra.ext.datalog.syntax.Rule +ruleWithAtomList :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.Rule +ruleWithAtomList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Atom"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"), + Model.projectionFieldName = (Model.Name "Atom")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "AtomList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the Constant variant of hydra.ext.datalog.syntax.Term +termConstant :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.Term +termConstant x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Term"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Constant"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the many variant of hydra.ext.datalog.syntax.TermList +termListMany :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList +termListMany x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "many"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.datalog.syntax.TermListMultiple +termListMultiple :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.TermListMultiple +termListMultiple term termList = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Term"), + Model.fieldTerm = (Typed.unTypedTerm term)}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Typed.unTypedTerm termList)}]})) + +-- | DSL accessor for the Term field of hydra.ext.datalog.syntax.TermListMultiple +termListMultipleTerm :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.Term +termListMultipleTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.projectionFieldName = (Model.Name "Term")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the TermList field of hydra.ext.datalog.syntax.TermListMultiple +termListMultipleTermList :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList +termListMultipleTermList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.projectionFieldName = (Model.Name "TermList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.TermListMultiple +termListMultipleTermListMultiple :: Typed.TypedName Syntax.TermListMultiple +termListMultipleTermListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.TermListMultiple") + +-- | DSL updater for the Term field of hydra.ext.datalog.syntax.TermListMultiple +termListMultipleWithTerm :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermListMultiple +termListMultipleWithTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Term"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.projectionFieldName = (Model.Name "TermList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the TermList field of hydra.ext.datalog.syntax.TermListMultiple +termListMultipleWithTermList :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.TermListMultiple +termListMultipleWithTermList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"), + Model.projectionFieldName = (Model.Name "Term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TermList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the single variant of hydra.ext.datalog.syntax.TermList +termListSingle :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermList +termListSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermList"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.datalog.syntax.TermList +termListTermList :: Typed.TypedName Syntax.TermList +termListTermList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.TermList") + +-- | DSL name token for hydra.ext.datalog.syntax.Term +termTerm :: Typed.TypedName Syntax.Term +termTerm = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Term") + +-- | DSL injection for the Variable variant of hydra.ext.datalog.syntax.Term +termVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Term +termVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Term"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the body of hydra.ext.datalog.syntax.Constant +unConstant :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm String +unConstant x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Constant")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.datalog.syntax.Program +unProgram :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ProgramElmt] +unProgram x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Program")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.datalog.syntax.Relation +unRelation :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm String +unRelation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Relation")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.datalog.syntax.Variable +unVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm String +unVariable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Variable")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.datalog.syntax.Variable wrapper +variable :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Variable +variable x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Variable"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.datalog.syntax.Variable +variableVariable :: Typed.TypedName Syntax.Variable +variableVariable = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Variable") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Delta/Parquet.hs b/src/main/haskell/Hydra/Ext/Dsl/Delta/Parquet.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Delta/Parquet.hs @@ -0,0 +1,573 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.delta.parquet + +module Hydra.Ext.Dsl.Delta.Parquet where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Delta.Parquet as Parquet +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.delta.parquet.ArrayType +arrayType :: Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.ArrayType +arrayType elementType containsNull = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm elementType)}, + Model.Field { + Model.fieldName = (Model.Name "containsNull"), + Model.fieldTerm = (Typed.unTypedTerm containsNull)}]})) + +-- | DSL name token for hydra.ext.delta.parquet.ArrayType +arrayTypeArrayType :: Typed.TypedName Parquet.ArrayType +arrayTypeArrayType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.ArrayType") + +-- | DSL accessor for the containsNull field of hydra.ext.delta.parquet.ArrayType +arrayTypeContainsNull :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Bool +arrayTypeContainsNull x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.projectionFieldName = (Model.Name "containsNull")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the elementType field of hydra.ext.delta.parquet.ArrayType +arrayTypeElementType :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType +arrayTypeElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the containsNull field of hydra.ext.delta.parquet.ArrayType +arrayTypeWithContainsNull :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.ArrayType +arrayTypeWithContainsNull original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.projectionFieldName = (Model.Name "elementType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "containsNull"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the elementType field of hydra.ext.delta.parquet.ArrayType +arrayTypeWithElementType :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.ArrayType +arrayTypeWithElementType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "elementType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "containsNull"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"), + Model.projectionFieldName = (Model.Name "containsNull")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeBasePrimitiveType :: Typed.TypedName Parquet.BasePrimitiveType +basePrimitiveTypeBasePrimitiveType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType") + +-- | DSL injection for the binary variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeBinary :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeBinary = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the boolean variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeBoolean :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the byte variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeByte :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeByte = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byte"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the date variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeDate :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeDate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "date"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeDouble :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeFloat :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the integer variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeInteger :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeInteger = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the long variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeLong :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the short variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeShort :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeShort = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "short"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeString :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the timestamp variant of hydra.ext.delta.parquet.BasePrimitiveType +basePrimitiveTypeTimestamp :: Typed.TypedTerm Parquet.BasePrimitiveType +basePrimitiveTypeTimestamp = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the array variant of hydra.ext.delta.parquet.DataType +dataTypeArray :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType +dataTypeArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the base variant of hydra.ext.delta.parquet.DataType +dataTypeBase :: Typed.TypedTerm Parquet.BasePrimitiveType -> Typed.TypedTerm Parquet.DataType +dataTypeBase x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "base"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.delta.parquet.DataType +dataTypeDataType :: Typed.TypedName Parquet.DataType +dataTypeDataType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.DataType") + +-- | DSL injection for the decimal variant of hydra.ext.delta.parquet.DataType +dataTypeDecimal :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Parquet.DataType +dataTypeDecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.delta.parquet.DataType +dataTypeMap :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType +dataTypeMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the struct variant of hydra.ext.delta.parquet.DataType +dataTypeStruct :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm Parquet.DataType +dataTypeStruct x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "struct"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.delta.parquet.DecimalType +decimalType :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType +decimalType precision scale = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Typed.unTypedTerm precision)}, + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Typed.unTypedTerm scale)}]})) + +-- | DSL name token for hydra.ext.delta.parquet.DecimalType +decimalTypeDecimalType :: Typed.TypedName Parquet.DecimalType +decimalTypeDecimalType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.DecimalType") + +-- | DSL accessor for the precision field of hydra.ext.delta.parquet.DecimalType +decimalTypePrecision :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int +decimalTypePrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.projectionFieldName = (Model.Name "precision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the scale field of hydra.ext.delta.parquet.DecimalType +decimalTypeScale :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int +decimalTypeScale x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.projectionFieldName = (Model.Name "scale")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the precision field of hydra.ext.delta.parquet.DecimalType +decimalTypeWithPrecision :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType +decimalTypeWithPrecision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.projectionFieldName = (Model.Name "scale")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the scale field of hydra.ext.delta.parquet.DecimalType +decimalTypeWithScale :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType +decimalTypeWithScale original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"), + Model.projectionFieldName = (Model.Name "precision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.delta.parquet.MapType +mapType :: Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.MapType +mapType keyType valueType valueContainsNull = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm keyType)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm valueType)}, + Model.Field { + Model.fieldName = (Model.Name "valueContainsNull"), + Model.fieldTerm = (Typed.unTypedTerm valueContainsNull)}]})) + +-- | DSL accessor for the keyType field of hydra.ext.delta.parquet.MapType +mapTypeKeyType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType +mapTypeKeyType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.delta.parquet.MapType +mapTypeMapType :: Typed.TypedName Parquet.MapType +mapTypeMapType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.MapType") + +-- | DSL accessor for the valueContainsNull field of hydra.ext.delta.parquet.MapType +mapTypeValueContainsNull :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Bool +mapTypeValueContainsNull x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueContainsNull")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the valueType field of hydra.ext.delta.parquet.MapType +mapTypeValueType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType +mapTypeValueType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the keyType field of hydra.ext.delta.parquet.MapType +mapTypeWithKeyType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.MapType +mapTypeWithKeyType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueContainsNull"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueContainsNull")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the valueContainsNull field of hydra.ext.delta.parquet.MapType +mapTypeWithValueContainsNull :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.MapType +mapTypeWithValueContainsNull original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueContainsNull"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the valueType field of hydra.ext.delta.parquet.MapType +mapTypeWithValueType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.MapType +mapTypeWithValueType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keyType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "keyType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "valueType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "valueContainsNull"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"), + Model.projectionFieldName = (Model.Name "valueContainsNull")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.delta.parquet.StructField +structField :: Typed.TypedTerm String -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.StructField +structField name dataType nullable = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "dataType"), + Model.fieldTerm = (Typed.unTypedTerm dataType)}, + Model.Field { + Model.fieldName = (Model.Name "nullable"), + Model.fieldTerm = (Typed.unTypedTerm nullable)}]})) + +-- | DSL accessor for the dataType field of hydra.ext.delta.parquet.StructField +structFieldDataType :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Parquet.DataType +structFieldDataType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "dataType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.delta.parquet.StructField +structFieldName :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm String +structFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nullable field of hydra.ext.delta.parquet.StructField +structFieldNullable :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Bool +structFieldNullable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "nullable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.delta.parquet.StructField +structFieldStructField :: Typed.TypedName Parquet.StructField +structFieldStructField = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.StructField") + +-- | DSL updater for the dataType field of hydra.ext.delta.parquet.StructField +structFieldWithDataType :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.StructField +structFieldWithDataType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nullable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "nullable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.delta.parquet.StructField +structFieldWithName :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm String -> Typed.TypedTerm Parquet.StructField +structFieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dataType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "dataType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "nullable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nullable field of hydra.ext.delta.parquet.StructField +structFieldWithNullable :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.StructField +structFieldWithNullable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"), + Model.projectionFieldName = (Model.Name "dataType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.delta.parquet.StructType +structType :: Typed.TypedTerm [Parquet.StructField] -> Typed.TypedTerm Parquet.StructType +structType fields = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}]})) + +-- | DSL accessor for the fields field of hydra.ext.delta.parquet.StructType +structTypeFields :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm [Parquet.StructField] +structTypeFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.delta.parquet.StructType +structTypeStructType :: Typed.TypedName Parquet.StructType +structTypeStructType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.StructType") + +-- | DSL updater for the fields field of hydra.ext.delta.parquet.StructType +structTypeWithFields :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm [Parquet.StructField] -> Typed.TypedTerm Parquet.StructType +structTypeWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Geojson/Model.hs b/src/main/haskell/Hydra/Ext/Dsl/Geojson/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Geojson/Model.hs @@ -0,0 +1,1075 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.geojson.model + +module Hydra.Ext.Dsl.Geojson.Model where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Geojson.Model as GeojsonModel +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for the hydra.ext.geojson.model.BoundingBox wrapper +boundingBox :: Typed.TypedTerm [GeojsonModel.CoordinateRange] -> Typed.TypedTerm GeojsonModel.BoundingBox +boundingBox x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.geojson.model.BoundingBox"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.BoundingBox +boundingBoxBoundingBox :: Typed.TypedName GeojsonModel.BoundingBox +boundingBoxBoundingBox = Typed.TypedName (Model.Name "hydra.ext.geojson.model.BoundingBox") + +-- | DSL constructor for hydra.ext.geojson.model.CoordinateRange +coordinateRange :: Typed.TypedTerm Double -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange +coordinateRange min max = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "min"), + Model.fieldTerm = (Typed.unTypedTerm min)}, + Model.Field { + Model.fieldName = (Model.Name "max"), + Model.fieldTerm = (Typed.unTypedTerm max)}]})) + +-- | DSL name token for hydra.ext.geojson.model.CoordinateRange +coordinateRangeCoordinateRange :: Typed.TypedName GeojsonModel.CoordinateRange +coordinateRangeCoordinateRange = Typed.TypedName (Model.Name "hydra.ext.geojson.model.CoordinateRange") + +-- | DSL accessor for the max field of hydra.ext.geojson.model.CoordinateRange +coordinateRangeMax :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double +coordinateRangeMax x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.projectionFieldName = (Model.Name "max")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the min field of hydra.ext.geojson.model.CoordinateRange +coordinateRangeMin :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double +coordinateRangeMin x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.projectionFieldName = (Model.Name "min")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the max field of hydra.ext.geojson.model.CoordinateRange +coordinateRangeWithMax :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange +coordinateRangeWithMax original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "min"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.projectionFieldName = (Model.Name "min")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "max"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the min field of hydra.ext.geojson.model.CoordinateRange +coordinateRangeWithMin :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange +coordinateRangeWithMin original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "min"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "max"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"), + Model.projectionFieldName = (Model.Name "max")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.Feature +feature :: Typed.TypedTerm (Maybe GeojsonModel.Geometry) -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value)) -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Feature +feature geometry properties id bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Typed.unTypedTerm geometry)}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Typed.unTypedTerm properties)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Feature +featureBbox :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +featureBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.geojson.model.FeatureCollection +featureCollection :: Typed.TypedTerm [GeojsonModel.Feature] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.FeatureCollection +featureCollection features bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "features"), + Model.fieldTerm = (Typed.unTypedTerm features)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.FeatureCollection +featureCollectionBbox :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +featureCollectionBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.FeatureCollection +featureCollectionFeatureCollection :: Typed.TypedName GeojsonModel.FeatureCollection +featureCollectionFeatureCollection = Typed.TypedName (Model.Name "hydra.ext.geojson.model.FeatureCollection") + +-- | DSL accessor for the features field of hydra.ext.geojson.model.FeatureCollection +featureCollectionFeatures :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm [GeojsonModel.Feature] +featureCollectionFeatures x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.projectionFieldName = (Model.Name "features")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.FeatureCollection +featureCollectionWithBbox :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.FeatureCollection +featureCollectionWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "features"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.projectionFieldName = (Model.Name "features")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the features field of hydra.ext.geojson.model.FeatureCollection +featureCollectionWithFeatures :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm [GeojsonModel.Feature] -> Typed.TypedTerm GeojsonModel.FeatureCollection +featureCollectionWithFeatures original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "features"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.geojson.model.Feature +featureFeature :: Typed.TypedName GeojsonModel.Feature +featureFeature = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Feature") + +-- | DSL accessor for the geometry field of hydra.ext.geojson.model.Feature +featureGeometry :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Geometry) +featureGeometry x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "geometry")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the id field of hydra.ext.geojson.model.Feature +featureId :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Id) +featureId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the properties field of hydra.ext.geojson.model.Feature +featureProperties :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value)) +featureProperties x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.Feature +featureWithBbox :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Feature +featureWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "geometry")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the geometry field of hydra.ext.geojson.model.Feature +featureWithGeometry :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Geometry) -> Typed.TypedTerm GeojsonModel.Feature +featureWithGeometry original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.geojson.model.Feature +featureWithId :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm GeojsonModel.Feature +featureWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "geometry")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "properties")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the properties field of hydra.ext.geojson.model.Feature +featureWithProperties :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value)) -> Typed.TypedTerm GeojsonModel.Feature +featureWithProperties original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "geometry")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.GeometryCollection +geometryCollection :: Typed.TypedTerm [GeojsonModel.Geometry] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.GeometryCollection +geometryCollection geometries bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometries"), + Model.fieldTerm = (Typed.unTypedTerm geometries)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.GeometryCollection +geometryCollectionBbox :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +geometryCollectionBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the geometries field of hydra.ext.geojson.model.GeometryCollection +geometryCollectionGeometries :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm [GeojsonModel.Geometry] +geometryCollectionGeometries x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.projectionFieldName = (Model.Name "geometries")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.GeometryCollection +geometryCollectionGeometryCollection :: Typed.TypedName GeojsonModel.GeometryCollection +geometryCollectionGeometryCollection = Typed.TypedName (Model.Name "hydra.ext.geojson.model.GeometryCollection") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.GeometryCollection +geometryCollectionWithBbox :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.GeometryCollection +geometryCollectionWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometries"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.projectionFieldName = (Model.Name "geometries")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the geometries field of hydra.ext.geojson.model.GeometryCollection +geometryCollectionWithGeometries :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm [GeojsonModel.Geometry] -> Typed.TypedTerm GeojsonModel.GeometryCollection +geometryCollectionWithGeometries original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "geometries"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.geojson.model.Geometry +geometryGeometry :: Typed.TypedName GeojsonModel.Geometry +geometryGeometry = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Geometry") + +-- | DSL injection for the geometryCollection variant of hydra.ext.geojson.model.Geometry +geometryGeometryCollection :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm GeojsonModel.Geometry +geometryGeometryCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "geometryCollection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lineString variant of hydra.ext.geojson.model.Geometry +geometryLineString :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm GeojsonModel.Geometry +geometryLineString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lineString"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multiLineString variant of hydra.ext.geojson.model.Geometry +geometryMultiLineString :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm GeojsonModel.Geometry +geometryMultiLineString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiLineString"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multiPoint variant of hydra.ext.geojson.model.Geometry +geometryMultiPoint :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm GeojsonModel.Geometry +geometryMultiPoint x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiPoint"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multiPolygon variant of hydra.ext.geojson.model.Geometry +geometryMultiPolygon :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm GeojsonModel.Geometry +geometryMultiPolygon x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiPolygon"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the point variant of hydra.ext.geojson.model.Geometry +geometryPoint :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Geometry +geometryPoint x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "point"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the polygon variant of hydra.ext.geojson.model.Geometry +geometryPolygon :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm GeojsonModel.Geometry +geometryPolygon x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "polygon"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.geojson.model.Id +idId :: Typed.TypedName GeojsonModel.Id +idId = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Id") + +-- | DSL injection for the number variant of hydra.ext.geojson.model.Id +idNumber :: Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Id +idNumber x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Id"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.geojson.model.Id +idString :: Typed.TypedTerm String -> Typed.TypedTerm GeojsonModel.Id +idString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Id"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.geojson.model.LineString +lineString :: Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.LineString +lineString coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.LineString +lineStringBbox :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +lineStringBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.LineString +lineStringCoordinates :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm [GeojsonModel.Position] +lineStringCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.LineString +lineStringLineString :: Typed.TypedName GeojsonModel.LineString +lineStringLineString = Typed.TypedName (Model.Name "hydra.ext.geojson.model.LineString") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.LineString +lineStringWithBbox :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.LineString +lineStringWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.LineString +lineStringWithCoordinates :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm GeojsonModel.LineString +lineStringWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.MultiLineString +multiLineString :: Typed.TypedTerm [GeojsonModel.LineString] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiLineString +multiLineString coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiLineString +multiLineStringBbox :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +multiLineStringBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiLineString +multiLineStringCoordinates :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm [GeojsonModel.LineString] +multiLineStringCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.MultiLineString +multiLineStringMultiLineString :: Typed.TypedName GeojsonModel.MultiLineString +multiLineStringMultiLineString = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiLineString") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiLineString +multiLineStringWithBbox :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiLineString +multiLineStringWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiLineString +multiLineStringWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm [GeojsonModel.LineString] -> Typed.TypedTerm GeojsonModel.MultiLineString +multiLineStringWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.MultiPoint +multiPoint :: Typed.TypedTerm [GeojsonModel.Point] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPoint +multiPoint coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiPoint +multiPointBbox :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +multiPointBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiPoint +multiPointCoordinates :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm [GeojsonModel.Point] +multiPointCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.MultiPoint +multiPointMultiPoint :: Typed.TypedName GeojsonModel.MultiPoint +multiPointMultiPoint = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiPoint") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiPoint +multiPointWithBbox :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPoint +multiPointWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiPoint +multiPointWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm [GeojsonModel.Point] -> Typed.TypedTerm GeojsonModel.MultiPoint +multiPointWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.MultiPolygon +multiPolygon :: Typed.TypedTerm [GeojsonModel.Polygon] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPolygon +multiPolygon coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiPolygon +multiPolygonBbox :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +multiPolygonBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiPolygon +multiPolygonCoordinates :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm [GeojsonModel.Polygon] +multiPolygonCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.MultiPolygon +multiPolygonMultiPolygon :: Typed.TypedName GeojsonModel.MultiPolygon +multiPolygonMultiPolygon = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiPolygon") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiPolygon +multiPolygonWithBbox :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPolygon +multiPolygonWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiPolygon +multiPolygonWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm [GeojsonModel.Polygon] -> Typed.TypedTerm GeojsonModel.MultiPolygon +multiPolygonWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the feature variant of hydra.ext.geojson.model.Object +objectFeature :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm GeojsonModel.Object +objectFeature x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the featureCollection variant of hydra.ext.geojson.model.Object +objectFeatureCollection :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm GeojsonModel.Object +objectFeatureCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "featureCollection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the geometry variant of hydra.ext.geojson.model.Object +objectGeometry :: Typed.TypedTerm GeojsonModel.Geometry -> Typed.TypedTerm GeojsonModel.Object +objectGeometry x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "geometry"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.geojson.model.Object +objectObject :: Typed.TypedName GeojsonModel.Object +objectObject = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Object") + +-- | DSL constructor for hydra.ext.geojson.model.Point +point :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Point +point coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Point +pointBbox :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +pointBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.Point +pointCoordinates :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Position +pointCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.Point +pointPoint :: Typed.TypedName GeojsonModel.Point +pointPoint = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Point") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.Point +pointWithBbox :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Point +pointWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.Point +pointWithCoordinates :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm GeojsonModel.Point +pointWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.Polygon +polygon :: Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Polygon +polygon coordinates bbox = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm coordinates)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm bbox)}]})) + +-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Polygon +polygonBbox :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) +polygonBbox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.Polygon +polygonCoordinates :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm [GeojsonModel.Position] +polygonCoordinates x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.Polygon +polygonPolygon :: Typed.TypedName GeojsonModel.Polygon +polygonPolygon = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Polygon") + +-- | DSL updater for the bbox field of hydra.ext.geojson.model.Polygon +polygonWithBbox :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Polygon +polygonWithBbox original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.projectionFieldName = (Model.Name "coordinates")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the coordinates field of hydra.ext.geojson.model.Polygon +polygonWithCoordinates :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm GeojsonModel.Polygon +polygonWithCoordinates original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "coordinates"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bbox"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"), + Model.projectionFieldName = (Model.Name "bbox")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.geojson.model.Position +position :: Typed.TypedTerm Double -> Typed.TypedTerm Double -> Typed.TypedTerm (Maybe Double) -> Typed.TypedTerm GeojsonModel.Position +position latitude longitude altitude = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "latitude"), + Model.fieldTerm = (Typed.unTypedTerm latitude)}, + Model.Field { + Model.fieldName = (Model.Name "longitude"), + Model.fieldTerm = (Typed.unTypedTerm longitude)}, + Model.Field { + Model.fieldName = (Model.Name "altitude"), + Model.fieldTerm = (Typed.unTypedTerm altitude)}]})) + +-- | DSL accessor for the altitude field of hydra.ext.geojson.model.Position +positionAltitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe Double) +positionAltitude x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "altitude")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the latitude field of hydra.ext.geojson.model.Position +positionLatitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double +positionLatitude x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "latitude")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the longitude field of hydra.ext.geojson.model.Position +positionLongitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double +positionLongitude x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "longitude")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.geojson.model.Position +positionPosition :: Typed.TypedName GeojsonModel.Position +positionPosition = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Position") + +-- | DSL updater for the altitude field of hydra.ext.geojson.model.Position +positionWithAltitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe Double) -> Typed.TypedTerm GeojsonModel.Position +positionWithAltitude original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "latitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "latitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "longitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "longitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "altitude"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the latitude field of hydra.ext.geojson.model.Position +positionWithLatitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Position +positionWithLatitude original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "latitude"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "longitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "longitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "altitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "altitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the longitude field of hydra.ext.geojson.model.Position +positionWithLongitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Position +positionWithLongitude original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "latitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "latitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "longitude"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "altitude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"), + Model.projectionFieldName = (Model.Name "altitude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the body of hydra.ext.geojson.model.BoundingBox +unBoundingBox :: Typed.TypedTerm GeojsonModel.BoundingBox -> Typed.TypedTerm [GeojsonModel.CoordinateRange] +unBoundingBox x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.geojson.model.BoundingBox")), + Model.applicationArgument = (Typed.unTypedTerm x)})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Graphql/Syntax.hs b/src/main/haskell/Hydra/Ext/Dsl/Graphql/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Graphql/Syntax.hs @@ -0,0 +1,7210 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.graphql.syntax + +module Hydra.Ext.Dsl.Graphql.Syntax where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Graphql.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL name token for hydra.ext.graphql.syntax.Alias +aliasAlias :: Typed.TypedName Syntax.Alias +aliasAlias = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Alias") + +-- | DSL injection for the Colon variant of hydra.ext.graphql.syntax.Alias +aliasColon :: Typed.TypedTerm Syntax.Alias +aliasColon = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Alias"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Colon"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the Name variant of hydra.ext.graphql.syntax.Alias +aliasName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Alias +aliasName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Alias"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.Argument +argument :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Value -> Typed.TypedTerm Syntax.Argument +argument name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.Argument +argumentArgument :: Typed.TypedName Syntax.Argument +argumentArgument = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Argument") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.Argument +argumentName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.Name +argumentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Value field of hydra.ext.graphql.syntax.Argument +argumentValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.Value +argumentValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.projectionFieldName = (Model.Name "Value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.Argument +argumentWithName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Argument +argumentWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.projectionFieldName = (Model.Name "Value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Value field of hydra.ext.graphql.syntax.Argument +argumentWithValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.Value -> Typed.TypedTerm Syntax.Argument +argumentWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Argument"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.Arguments wrapper +arguments :: Typed.TypedTerm [Syntax.Argument] -> Typed.TypedTerm Syntax.Arguments +arguments x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Arguments"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Arguments +argumentsArguments :: Typed.TypedName Syntax.Arguments +argumentsArguments = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Arguments") + +-- | DSL constructor for the hydra.ext.graphql.syntax.ArgumentsDefinition wrapper +argumentsDefinition :: Typed.TypedTerm [Syntax.InputValueDefinition] -> Typed.TypedTerm Syntax.ArgumentsDefinition +argumentsDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.ArgumentsDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ArgumentsDefinition +argumentsDefinitionArgumentsDefinition :: Typed.TypedName Syntax.ArgumentsDefinition +argumentsDefinitionArgumentsDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ArgumentsDefinition") + +-- | DSL name token for hydra.ext.graphql.syntax.BooleanValue +booleanValueBooleanValue :: Typed.TypedName Syntax.BooleanValue +booleanValueBooleanValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.BooleanValue") + +-- | DSL injection for the False variant of hydra.ext.graphql.syntax.BooleanValue +booleanValueFalse :: Typed.TypedTerm Syntax.BooleanValue +booleanValueFalse = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.BooleanValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "False"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the True variant of hydra.ext.graphql.syntax.BooleanValue +booleanValueTrue :: Typed.TypedTerm Syntax.BooleanValue +booleanValueTrue = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.BooleanValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "True"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.DefaultValue wrapper +defaultValue :: Typed.TypedTerm Syntax.Value -> Typed.TypedTerm Syntax.DefaultValue +defaultValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.DefaultValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.DefaultValue +defaultValueDefaultValue :: Typed.TypedName Syntax.DefaultValue +defaultValueDefaultValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DefaultValue") + +-- | DSL name token for hydra.ext.graphql.syntax.Definition +definitionDefinition :: Typed.TypedName Syntax.Definition +definitionDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Definition") + +-- | DSL injection for the executable variant of hydra.ext.graphql.syntax.Definition +definitionExecutable :: Typed.TypedTerm Syntax.ExecutableDefinition -> Typed.TypedTerm Syntax.Definition +definitionExecutable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Definition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "executable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeSystem variant of hydra.ext.graphql.syntax.Definition +definitionTypeSystem :: Typed.TypedTerm Syntax.TypeSystemDefinitionOrExtension -> Typed.TypedTerm Syntax.Definition +definitionTypeSystem x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Definition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeSystem"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.Description wrapper +description :: Typed.TypedTerm Syntax.StringValue -> Typed.TypedTerm Syntax.Description +description x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Description"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Description +descriptionDescription :: Typed.TypedName Syntax.Description +descriptionDescription = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Description") + +-- | DSL constructor for hydra.ext.graphql.syntax.Directive +directive :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Arguments) -> Typed.TypedTerm Syntax.Directive +directive name arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the Arguments field of hydra.ext.graphql.syntax.Directive +directiveArguments :: Typed.TypedTerm Syntax.Directive -> Typed.TypedTerm (Maybe Syntax.Arguments) +directiveArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.DirectiveLocations -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinition description name argumentsDefinition repeatable directiveLocations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm argumentsDefinition)}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Typed.unTypedTerm repeatable)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Typed.unTypedTerm directiveLocations)}]})) + +-- | DSL accessor for the ArgumentsDefinition field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionArgumentsDefinition :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) +directiveDefinitionArgumentsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionDescription :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +directiveDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionDirectiveDefinition :: Typed.TypedName Syntax.DirectiveDefinition +directiveDefinitionDirectiveDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition") + +-- | DSL accessor for the DirectiveLocations field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionDirectiveLocations :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm Syntax.DirectiveLocations +directiveDefinitionDirectiveLocations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionName :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm Syntax.Name +directiveDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Repeatable field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionRepeatable :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe ()) +directiveDefinitionRepeatable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Repeatable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ArgumentsDefinition field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionWithArgumentsDefinition :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinitionWithArgumentsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Repeatable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionWithDescription :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Repeatable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the DirectiveLocations field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionWithDirectiveLocations :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm Syntax.DirectiveLocations -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinitionWithDirectiveLocations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Repeatable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionWithName :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Repeatable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Repeatable field of hydra.ext.graphql.syntax.DirectiveDefinition +directiveDefinitionWithRepeatable :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.DirectiveDefinition +directiveDefinitionWithRepeatable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Repeatable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.Directive +directiveDirective :: Typed.TypedName Syntax.Directive +directiveDirective = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Directive") + +-- | DSL name token for hydra.ext.graphql.syntax.DirectiveLocation +directiveLocationDirectiveLocation :: Typed.TypedName Syntax.DirectiveLocation +directiveLocationDirectiveLocation = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DirectiveLocation") + +-- | DSL injection for the executable variant of hydra.ext.graphql.syntax.DirectiveLocation +directiveLocationExecutable :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocation +directiveLocationExecutable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "executable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeSystem variant of hydra.ext.graphql.syntax.DirectiveLocation +directiveLocationTypeSystem :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocation +directiveLocationTypeSystem x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeSystem"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.DirectiveLocations +directiveLocationsDirectiveLocations :: Typed.TypedName Syntax.DirectiveLocations +directiveLocationsDirectiveLocations = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DirectiveLocations") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.DirectiveLocations +directiveLocationsSeq :: Typed.TypedTerm Syntax.DirectiveLocationsSequence -> Typed.TypedTerm Syntax.DirectiveLocations +directiveLocationsSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.DirectiveLocations +directiveLocationsSeq2 :: Typed.TypedTerm Syntax.DirectiveLocationsSequence2 -> Typed.TypedTerm Syntax.DirectiveLocations +directiveLocationsSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocations"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequence :: Typed.TypedTerm Syntax.DirectiveLocations -> Typed.TypedTerm Syntax.DirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocationsSequence +directiveLocationsSequence directiveLocations directiveLocation = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Typed.unTypedTerm directiveLocations)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Typed.unTypedTerm directiveLocation)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2 :: Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.DirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2 or directiveLocation = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Typed.unTypedTerm or)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Typed.unTypedTerm directiveLocation)}]})) + +-- | DSL accessor for the DirectiveLocation field of hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2DirectiveLocation :: Typed.TypedTerm Syntax.DirectiveLocationsSequence2 -> Typed.TypedTerm Syntax.DirectiveLocation +directiveLocationsSequence2DirectiveLocation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.projectionFieldName = (Model.Name "DirectiveLocation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2DirectiveLocationsSequence2 :: Typed.TypedName Syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2DirectiveLocationsSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2") + +-- | DSL accessor for the Or field of hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2Or :: Typed.TypedTerm Syntax.DirectiveLocationsSequence2 -> Typed.TypedTerm (Maybe ()) +directiveLocationsSequence2Or x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.projectionFieldName = (Model.Name "Or")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the DirectiveLocation field of hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2WithDirectiveLocation :: Typed.TypedTerm Syntax.DirectiveLocationsSequence2 -> Typed.TypedTerm Syntax.DirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2WithDirectiveLocation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.projectionFieldName = (Model.Name "Or")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Or field of hydra.ext.graphql.syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2WithOr :: Typed.TypedTerm Syntax.DirectiveLocationsSequence2 -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.DirectiveLocationsSequence2 +directiveLocationsSequence2WithOr original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2"), + Model.projectionFieldName = (Model.Name "DirectiveLocation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the DirectiveLocation field of hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequenceDirectiveLocation :: Typed.TypedTerm Syntax.DirectiveLocationsSequence -> Typed.TypedTerm Syntax.DirectiveLocation +directiveLocationsSequenceDirectiveLocation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.projectionFieldName = (Model.Name "DirectiveLocation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the DirectiveLocations field of hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequenceDirectiveLocations :: Typed.TypedTerm Syntax.DirectiveLocationsSequence -> Typed.TypedTerm Syntax.DirectiveLocations +directiveLocationsSequenceDirectiveLocations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequenceDirectiveLocationsSequence :: Typed.TypedName Syntax.DirectiveLocationsSequence +directiveLocationsSequenceDirectiveLocationsSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence") + +-- | DSL updater for the DirectiveLocation field of hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequenceWithDirectiveLocation :: Typed.TypedTerm Syntax.DirectiveLocationsSequence -> Typed.TypedTerm Syntax.DirectiveLocation -> Typed.TypedTerm Syntax.DirectiveLocationsSequence +directiveLocationsSequenceWithDirectiveLocation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.projectionFieldName = (Model.Name "DirectiveLocations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the DirectiveLocations field of hydra.ext.graphql.syntax.DirectiveLocationsSequence +directiveLocationsSequenceWithDirectiveLocations :: Typed.TypedTerm Syntax.DirectiveLocationsSequence -> Typed.TypedTerm Syntax.DirectiveLocations -> Typed.TypedTerm Syntax.DirectiveLocationsSequence +directiveLocationsSequenceWithDirectiveLocations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "DirectiveLocation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence"), + Model.projectionFieldName = (Model.Name "DirectiveLocation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.Directive +directiveName :: Typed.TypedTerm Syntax.Directive -> Typed.TypedTerm Syntax.Name +directiveName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Arguments field of hydra.ext.graphql.syntax.Directive +directiveWithArguments :: Typed.TypedTerm Syntax.Directive -> Typed.TypedTerm (Maybe Syntax.Arguments) -> Typed.TypedTerm Syntax.Directive +directiveWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.Directive +directiveWithName :: Typed.TypedTerm Syntax.Directive -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Directive +directiveWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Directive"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.Directives wrapper +directives :: Typed.TypedTerm [Syntax.Directive] -> Typed.TypedTerm Syntax.Directives +directives x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Directives"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Directives +directivesDirectives :: Typed.TypedName Syntax.Directives +directivesDirectives = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Directives") + +-- | DSL constructor for the hydra.ext.graphql.syntax.Document wrapper +document :: Typed.TypedTerm [Syntax.Definition] -> Typed.TypedTerm Syntax.Document +document x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Document"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Document +documentDocument :: Typed.TypedName Syntax.Document +documentDocument = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Document") + +-- | DSL constructor for hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm (Maybe Syntax.EnumValuesDefinition) -> Typed.TypedTerm Syntax.EnumTypeDefinition +enumTypeDefinition description name directives enumValuesDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm enumValuesDefinition)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionDescription :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +enumTypeDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionDirectives :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +enumTypeDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionEnumTypeDefinition :: Typed.TypedName Syntax.EnumTypeDefinition +enumTypeDefinitionEnumTypeDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition") + +-- | DSL accessor for the EnumValuesDefinition field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionEnumValuesDefinition :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.EnumValuesDefinition) +enumTypeDefinitionEnumValuesDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionName :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm Syntax.Name +enumTypeDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionWithDescription :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.EnumTypeDefinition +enumTypeDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionWithDirectives :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.EnumTypeDefinition +enumTypeDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the EnumValuesDefinition field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionWithEnumValuesDefinition :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm (Maybe Syntax.EnumValuesDefinition) -> Typed.TypedTerm Syntax.EnumTypeDefinition +enumTypeDefinitionWithEnumValuesDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.EnumTypeDefinition +enumTypeDefinitionWithName :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.EnumTypeDefinition +enumTypeDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumTypeExtension +enumTypeExtensionEnumTypeExtension :: Typed.TypedName Syntax.EnumTypeExtension +enumTypeExtensionEnumTypeExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtension") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.EnumTypeExtension +enumTypeExtensionSeq :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm Syntax.EnumTypeExtension +enumTypeExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.EnumTypeExtension +enumTypeExtensionSeq2 :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 -> Typed.TypedTerm Syntax.EnumTypeExtension +enumTypeExtensionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequence :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.EnumValuesDefinition -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence +enumTypeExtensionSequence name directives enumValuesDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm enumValuesDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2 name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2Directives :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives +enumTypeExtensionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2EnumTypeExtensionSequence2 :: Typed.TypedName Syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2EnumTypeExtensionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2Name :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name +enumTypeExtensionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2WithDirectives :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2WithName :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence2 +enumTypeExtensionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceDirectives :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +enumTypeExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceEnumTypeExtensionSequence :: Typed.TypedName Syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceEnumTypeExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence") + +-- | DSL accessor for the EnumValuesDefinition field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceEnumValuesDefinition :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm Syntax.EnumValuesDefinition +enumTypeExtensionSequenceEnumValuesDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceName :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm Syntax.Name +enumTypeExtensionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the EnumValuesDefinition field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithEnumValuesDefinition :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm Syntax.EnumValuesDefinition -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithEnumValuesDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithName :: Typed.TypedTerm Syntax.EnumTypeExtensionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.EnumTypeExtensionSequence +enumTypeExtensionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValuesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "EnumValuesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.EnumValue wrapper +enumValue :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.EnumValue +enumValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.EnumValue -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.EnumValueDefinition +enumValueDefinition description enumValue directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValue"), + Model.fieldTerm = (Typed.unTypedTerm enumValue)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionDescription :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +enumValueDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionDirectives :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +enumValueDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the EnumValue field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionEnumValue :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm Syntax.EnumValue +enumValueDefinitionEnumValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "EnumValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionEnumValueDefinition :: Typed.TypedName Syntax.EnumValueDefinition +enumValueDefinitionEnumValueDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition") + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionWithDescription :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.EnumValueDefinition +enumValueDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "EnumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "EnumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionWithDirectives :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.EnumValueDefinition +enumValueDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "EnumValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the EnumValue field of hydra.ext.graphql.syntax.EnumValueDefinition +enumValueDefinitionWithEnumValue :: Typed.TypedTerm Syntax.EnumValueDefinition -> Typed.TypedTerm Syntax.EnumValue -> Typed.TypedTerm Syntax.EnumValueDefinition +enumValueDefinitionWithEnumValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "EnumValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumValue +enumValueEnumValue :: Typed.TypedName Syntax.EnumValue +enumValueEnumValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumValue") + +-- | DSL constructor for the hydra.ext.graphql.syntax.EnumValuesDefinition wrapper +enumValuesDefinition :: Typed.TypedTerm [Syntax.EnumValueDefinition] -> Typed.TypedTerm Syntax.EnumValuesDefinition +enumValuesDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.EnumValuesDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.EnumValuesDefinition +enumValuesDefinitionEnumValuesDefinition :: Typed.TypedName Syntax.EnumValuesDefinition +enumValuesDefinitionEnumValuesDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.EnumValuesDefinition") + +-- | DSL name token for hydra.ext.graphql.syntax.ExecutableDefinition +executableDefinitionExecutableDefinition :: Typed.TypedName Syntax.ExecutableDefinition +executableDefinitionExecutableDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ExecutableDefinition") + +-- | DSL injection for the fragment variant of hydra.ext.graphql.syntax.ExecutableDefinition +executableDefinitionFragment :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.ExecutableDefinition +executableDefinitionFragment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fragment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the operation variant of hydra.ext.graphql.syntax.ExecutableDefinition +executableDefinitionOperation :: Typed.TypedTerm Syntax.OperationDefinition -> Typed.TypedTerm Syntax.ExecutableDefinition +executableDefinitionOperation x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "operation"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationExecutableDirectiveLocation :: Typed.TypedName Syntax.ExecutableDirectiveLocation +executableDirectiveLocationExecutableDirectiveLocation = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation") + +-- | DSL injection for the FIELD variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationFIELD :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationFIELD = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FIELD"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the FRAGMENT_DEFINITION variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationFRAGMENT_DEFINITION :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationFRAGMENT_DEFINITION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FRAGMENT_DEFINITION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the FRAGMENT_SPREAD variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationFRAGMENT_SPREAD :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationFRAGMENT_SPREAD = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FRAGMENT_SPREAD"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the INLINE_FRAGMENT variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationINLINE_FRAGMENT :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationINLINE_FRAGMENT = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "INLINE_FRAGMENT"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the MUTATION variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationMUTATION :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationMUTATION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "MUTATION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the QUERY variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationQUERY :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationQUERY = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "QUERY"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the SUBSCRIPTION variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationSUBSCRIPTION :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationSUBSCRIPTION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "SUBSCRIPTION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the VARIABLE_DEFINITION variant of hydra.ext.graphql.syntax.ExecutableDirectiveLocation +executableDirectiveLocationVARIABLE_DEFINITION :: Typed.TypedTerm Syntax.ExecutableDirectiveLocation +executableDirectiveLocationVARIABLE_DEFINITION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "VARIABLE_DEFINITION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.ExecutableDocument wrapper +executableDocument :: Typed.TypedTerm [Syntax.ExecutableDefinition] -> Typed.TypedTerm Syntax.ExecutableDocument +executableDocument x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.ExecutableDocument"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ExecutableDocument +executableDocumentExecutableDocument :: Typed.TypedName Syntax.ExecutableDocument +executableDocumentExecutableDocument = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ExecutableDocument") + +-- | DSL constructor for hydra.ext.graphql.syntax.Field +field :: Typed.TypedTerm (Maybe Syntax.Alias) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Arguments) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm (Maybe Syntax.SelectionSet) -> Typed.TypedTerm Syntax.Field +field alias name arguments directives selectionSet = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm selectionSet)}]})) + +-- | DSL accessor for the Alias field of hydra.ext.graphql.syntax.Field +fieldAlias :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Alias) +fieldAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Arguments field of hydra.ext.graphql.syntax.Field +fieldArguments :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Arguments) +fieldArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.graphql.syntax.FieldDefinition +fieldDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinition description name argumentsDefinition type_ directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm argumentsDefinition)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the ArgumentsDefinition field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionArgumentsDefinition :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) +fieldDefinitionArgumentsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionDescription :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +fieldDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionDirectives :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +fieldDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionFieldDefinition :: Typed.TypedName Syntax.FieldDefinition +fieldDefinitionFieldDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FieldDefinition") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Name +fieldDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Type field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionType :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Type +fieldDefinitionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ArgumentsDefinition field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionWithArgumentsDefinition :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.ArgumentsDefinition) -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinitionWithArgumentsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionWithDescription :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionWithDirectives :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionWithName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Type field of hydra.ext.graphql.syntax.FieldDefinition +fieldDefinitionWithType :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FieldDefinition +fieldDefinitionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArgumentsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "ArgumentsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.Field +fieldDirectives :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Directives) +fieldDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Field +fieldField :: Typed.TypedName Syntax.Field +fieldField = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Field") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.Field +fieldName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name +fieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the SelectionSet field of hydra.ext.graphql.syntax.Field +fieldSelectionSet :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.SelectionSet) +fieldSelectionSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Alias field of hydra.ext.graphql.syntax.Field +fieldWithAlias :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Alias) -> Typed.TypedTerm Syntax.Field +fieldWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Arguments field of hydra.ext.graphql.syntax.Field +fieldWithArguments :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Arguments) -> Typed.TypedTerm Syntax.Field +fieldWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.Field +fieldWithDirectives :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.Field +fieldWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.Field +fieldWithName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Field +fieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the SelectionSet field of hydra.ext.graphql.syntax.Field +fieldWithSelectionSet :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe Syntax.SelectionSet) -> Typed.TypedTerm Syntax.Field +fieldWithSelectionSet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Field"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.FieldsDefinition wrapper +fieldsDefinition :: Typed.TypedTerm [Syntax.FieldDefinition] -> Typed.TypedTerm Syntax.FieldsDefinition +fieldsDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.FieldsDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FieldsDefinition +fieldsDefinitionFieldsDefinition :: Typed.TypedName Syntax.FieldsDefinition +fieldsDefinitionFieldsDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FieldsDefinition") + +-- | DSL constructor for the hydra.ext.graphql.syntax.FloatValue wrapper +floatValue :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.FloatValue +floatValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.FloatValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FloatValue +floatValueFloatValue :: Typed.TypedName Syntax.FloatValue +floatValueFloatValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FloatValue") + +-- | DSL constructor for hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinition :: Typed.TypedTerm Syntax.FragmentName -> Typed.TypedTerm Syntax.TypeCondition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.FragmentDefinition +fragmentDefinition fragmentName typeCondition directives selectionSet = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Typed.unTypedTerm fragmentName)}, + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Typed.unTypedTerm typeCondition)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm selectionSet)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionDirectives :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +fragmentDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionFragmentDefinition :: Typed.TypedName Syntax.FragmentDefinition +fragmentDefinitionFragmentDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition") + +-- | DSL accessor for the FragmentName field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionFragmentName :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.FragmentName +fragmentDefinitionFragmentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the SelectionSet field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionSelectionSet :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.SelectionSet +fragmentDefinitionSelectionSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the TypeCondition field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionTypeCondition :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.TypeCondition +fragmentDefinitionTypeCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionWithDirectives :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FragmentDefinition +fragmentDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the FragmentName field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionWithFragmentName :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.FragmentName -> Typed.TypedTerm Syntax.FragmentDefinition +fragmentDefinitionWithFragmentName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the SelectionSet field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionWithSelectionSet :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.FragmentDefinition +fragmentDefinitionWithSelectionSet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the TypeCondition field of hydra.ext.graphql.syntax.FragmentDefinition +fragmentDefinitionWithTypeCondition :: Typed.TypedTerm Syntax.FragmentDefinition -> Typed.TypedTerm Syntax.TypeCondition -> Typed.TypedTerm Syntax.FragmentDefinition +fragmentDefinitionWithTypeCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentDefinition"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.FragmentName wrapper +fragmentName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.FragmentName +fragmentName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FragmentName +fragmentNameFragmentName :: Typed.TypedName Syntax.FragmentName +fragmentNameFragmentName = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FragmentName") + +-- | DSL constructor for hydra.ext.graphql.syntax.FragmentSpread +fragmentSpread :: Typed.TypedTerm Syntax.FragmentName -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FragmentSpread +fragmentSpread fragmentName directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Typed.unTypedTerm fragmentName)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.FragmentSpread +fragmentSpreadDirectives :: Typed.TypedTerm Syntax.FragmentSpread -> Typed.TypedTerm (Maybe Syntax.Directives) +fragmentSpreadDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the FragmentName field of hydra.ext.graphql.syntax.FragmentSpread +fragmentSpreadFragmentName :: Typed.TypedTerm Syntax.FragmentSpread -> Typed.TypedTerm Syntax.FragmentName +fragmentSpreadFragmentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.FragmentSpread +fragmentSpreadFragmentSpread :: Typed.TypedName Syntax.FragmentSpread +fragmentSpreadFragmentSpread = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.FragmentSpread") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.FragmentSpread +fragmentSpreadWithDirectives :: Typed.TypedTerm Syntax.FragmentSpread -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FragmentSpread +fragmentSpreadWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.projectionFieldName = (Model.Name "FragmentName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the FragmentName field of hydra.ext.graphql.syntax.FragmentSpread +fragmentSpreadWithFragmentName :: Typed.TypedTerm Syntax.FragmentSpread -> Typed.TypedTerm Syntax.FragmentName -> Typed.TypedTerm Syntax.FragmentSpread +fragmentSpreadWithFragmentName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "FragmentName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.FragmentSpread"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.ImplementsInterfaces +implementsInterfacesImplementsInterfaces :: Typed.TypedName Syntax.ImplementsInterfaces +implementsInterfacesImplementsInterfaces = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfaces") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.ImplementsInterfaces +implementsInterfacesSeq :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence -> Typed.TypedTerm Syntax.ImplementsInterfaces +implementsInterfacesSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfaces"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.ImplementsInterfaces +implementsInterfacesSeq2 :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 -> Typed.TypedTerm Syntax.ImplementsInterfaces +implementsInterfacesSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfaces"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequence :: Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence +implementsInterfacesSequence implementsInterfaces namedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm namedType)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2 :: Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2 amp namedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Amp"), + Model.fieldTerm = (Typed.unTypedTerm amp)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm namedType)}]})) + +-- | DSL accessor for the Amp field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2Amp :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 -> Typed.TypedTerm (Maybe ()) +implementsInterfacesSequence2Amp x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.projectionFieldName = (Model.Name "Amp")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2ImplementsInterfacesSequence2 :: Typed.TypedName Syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2ImplementsInterfacesSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2") + +-- | DSL accessor for the NamedType field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2NamedType :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 -> Typed.TypedTerm Syntax.NamedType +implementsInterfacesSequence2NamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Amp field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2WithAmp :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2WithAmp original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Amp"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the NamedType field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2WithNamedType :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence2 +implementsInterfacesSequence2WithNamedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Amp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2"), + Model.projectionFieldName = (Model.Name "Amp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceImplementsInterfaces :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence -> Typed.TypedTerm Syntax.ImplementsInterfaces +implementsInterfacesSequenceImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceImplementsInterfacesSequence :: Typed.TypedName Syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceImplementsInterfacesSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence") + +-- | DSL accessor for the NamedType field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceNamedType :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence -> Typed.TypedTerm Syntax.NamedType +implementsInterfacesSequenceNamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceWithImplementsInterfaces :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceWithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the NamedType field of hydra.ext.graphql.syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceWithNamedType :: Typed.TypedTerm Syntax.ImplementsInterfacesSequence -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.ImplementsInterfacesSequence +implementsInterfacesSequenceWithNamedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InlineFragment +inlineFragment :: Typed.TypedTerm (Maybe Syntax.TypeCondition) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.InlineFragment +inlineFragment typeCondition directives selectionSet = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Typed.unTypedTerm typeCondition)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm selectionSet)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentDirectives :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm (Maybe Syntax.Directives) +inlineFragmentDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InlineFragment +inlineFragmentInlineFragment :: Typed.TypedName Syntax.InlineFragment +inlineFragmentInlineFragment = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InlineFragment") + +-- | DSL accessor for the SelectionSet field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentSelectionSet :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm Syntax.SelectionSet +inlineFragmentSelectionSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the TypeCondition field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentTypeCondition :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm (Maybe Syntax.TypeCondition) +inlineFragmentTypeCondition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentWithDirectives :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InlineFragment +inlineFragmentWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the SelectionSet field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentWithSelectionSet :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.InlineFragment +inlineFragmentWithSelectionSet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "TypeCondition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the TypeCondition field of hydra.ext.graphql.syntax.InlineFragment +inlineFragmentWithTypeCondition :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm (Maybe Syntax.TypeCondition) -> Typed.TypedTerm Syntax.InlineFragment +inlineFragmentWithTypeCondition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "TypeCondition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InlineFragment"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.InputFieldsDefinition wrapper +inputFieldsDefinition :: Typed.TypedTerm [Syntax.InputValueDefinition] -> Typed.TypedTerm Syntax.InputFieldsDefinition +inputFieldsDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.InputFieldsDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputFieldsDefinition +inputFieldsDefinitionInputFieldsDefinition :: Typed.TypedName Syntax.InputFieldsDefinition +inputFieldsDefinitionInputFieldsDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputFieldsDefinition") + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionInputObjectTypeDefinition :: Typed.TypedName Syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionInputObjectTypeDefinition = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinition") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionSeq :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm Syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionSeq2 :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.InputObjectTypeDefinition +inputObjectTypeDefinitionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequence :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputFieldsDefinition -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequence description name directives inputFieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm inputFieldsDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2 :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2 description name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2Description :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Description) +inputObjectTypeDefinitionSequence2Description x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2Directives :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) +inputObjectTypeDefinitionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2InputObjectTypeDefinitionSequence2 :: Typed.TypedName Syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2InputObjectTypeDefinitionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2Name :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.Name +inputObjectTypeDefinitionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithDescription :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithDirectives :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithName :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence2 +inputObjectTypeDefinitionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceDescription :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Description) +inputObjectTypeDefinitionSequenceDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceDirectives :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +inputObjectTypeDefinitionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the InputFieldsDefinition field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceInputFieldsDefinition :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm Syntax.InputFieldsDefinition +inputObjectTypeDefinitionSequenceInputFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceInputObjectTypeDefinitionSequence :: Typed.TypedName Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceInputObjectTypeDefinitionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceName :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm Syntax.Name +inputObjectTypeDefinitionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithDescription :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithDirectives :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the InputFieldsDefinition field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithInputFieldsDefinition :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm Syntax.InputFieldsDefinition -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithInputFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithName :: Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InputObjectTypeDefinitionSequence +inputObjectTypeDefinitionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeExtension +inputObjectTypeExtensionInputObjectTypeExtension :: Typed.TypedName Syntax.InputObjectTypeExtension +inputObjectTypeExtensionInputObjectTypeExtension = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtension") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.InputObjectTypeExtension +inputObjectTypeExtensionSeq :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.InputObjectTypeExtension +inputObjectTypeExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.InputObjectTypeExtension +inputObjectTypeExtensionSeq2 :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.InputObjectTypeExtension +inputObjectTypeExtensionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequence :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputFieldsDefinition -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequence name directives inputFieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm inputFieldsDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2 name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2Directives :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives +inputObjectTypeExtensionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2InputObjectTypeExtensionSequence2 :: Typed.TypedName Syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2InputObjectTypeExtensionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2Name :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name +inputObjectTypeExtensionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2WithDirectives :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2WithName :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence2 +inputObjectTypeExtensionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceDirectives :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +inputObjectTypeExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the InputFieldsDefinition field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceInputFieldsDefinition :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.InputFieldsDefinition +inputObjectTypeExtensionSequenceInputFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceInputObjectTypeExtensionSequence :: Typed.TypedName Syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceInputObjectTypeExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceName :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.Name +inputObjectTypeExtensionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the InputFieldsDefinition field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithInputFieldsDefinition :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.InputFieldsDefinition -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithInputFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithName :: Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InputObjectTypeExtensionSequence +inputObjectTypeExtensionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "InputFieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "InputFieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinition description name type_ defaultValue directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Typed.unTypedTerm defaultValue)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the DefaultValue field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionDefaultValue :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.DefaultValue) +inputValueDefinitionDefaultValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionDescription :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +inputValueDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionDirectives :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +inputValueDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionInputValueDefinition :: Typed.TypedName Syntax.InputValueDefinition +inputValueDefinitionInputValueDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionName :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm Syntax.Name +inputValueDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Type field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionType :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm Syntax.Type +inputValueDefinitionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the DefaultValue field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionWithDefaultValue :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinitionWithDefaultValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionWithDescription :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionWithDirectives :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionWithName :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Type field of hydra.ext.graphql.syntax.InputValueDefinition +inputValueDefinitionWithType :: Typed.TypedTerm Syntax.InputValueDefinition -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InputValueDefinition +inputValueDefinitionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InputValueDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.IntValue wrapper +intValue :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntValue +intValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.IntValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.IntValue +intValueIntValue :: Typed.TypedName Syntax.IntValue +intValueIntValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.IntValue") + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeDefinition +interfaceTypeDefinitionInterfaceTypeDefinition :: Typed.TypedName Syntax.InterfaceTypeDefinition +interfaceTypeDefinitionInterfaceTypeDefinition = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinition") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.InterfaceTypeDefinition +interfaceTypeDefinitionSeq :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm Syntax.InterfaceTypeDefinition +interfaceTypeDefinitionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.InterfaceTypeDefinition +interfaceTypeDefinitionSeq2 :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.InterfaceTypeDefinition +interfaceTypeDefinitionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequence :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequence description name implementsInterfaces directives fieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm fieldsDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2 :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2 description name implementsInterfaces directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2Description :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Description) +interfaceTypeDefinitionSequence2Description x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2Directives :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) +interfaceTypeDefinitionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2ImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.ImplementsInterfaces +interfaceTypeDefinitionSequence2ImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2InterfaceTypeDefinitionSequence2 :: Typed.TypedName Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2InterfaceTypeDefinitionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2Name :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.Name +interfaceTypeDefinitionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithDescription :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithDirectives :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithName :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence2 +interfaceTypeDefinitionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceDescription :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Description) +interfaceTypeDefinitionSequenceDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceDirectives :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +interfaceTypeDefinitionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the FieldsDefinition field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceFieldsDefinition :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm Syntax.FieldsDefinition +interfaceTypeDefinitionSequenceFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +interfaceTypeDefinitionSequenceImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceInterfaceTypeDefinitionSequence :: Typed.TypedName Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceInterfaceTypeDefinitionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceName :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm Syntax.Name +interfaceTypeDefinitionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithDescription :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithDirectives :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the FieldsDefinition field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithFieldsDefinition :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithName :: Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InterfaceTypeDefinitionSequence +interfaceTypeDefinitionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeExtension +interfaceTypeExtensionInterfaceTypeExtension :: Typed.TypedName Syntax.InterfaceTypeExtension +interfaceTypeExtensionInterfaceTypeExtension = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtension") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm Syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq2 :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm Syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq3 variant of hydra.ext.graphql.syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq3 :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 -> Typed.TypedTerm Syntax.InterfaceTypeExtension +interfaceTypeExtensionSeq3 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq3"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequence :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequence name implementsInterfaces directives fieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm fieldsDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2 name implementsInterfaces directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2Directives :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives +interfaceTypeExtensionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2ImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +interfaceTypeExtensionSequence2ImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2InterfaceTypeExtensionSequence2 :: Typed.TypedName Syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2InterfaceTypeExtensionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2Name :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name +interfaceTypeExtensionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithDirectives :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithName :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence2 +interfaceTypeExtensionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3 name implementsInterfaces = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}]})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3ImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 -> Typed.TypedTerm Syntax.ImplementsInterfaces +interfaceTypeExtensionSequence3ImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3InterfaceTypeExtensionSequence3 :: Typed.TypedName Syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3InterfaceTypeExtensionSequence3 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3Name :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 -> Typed.TypedTerm Syntax.Name +interfaceTypeExtensionSequence3Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3WithImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3WithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3WithName :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence3 +interfaceTypeExtensionSequence3WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceDirectives :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +interfaceTypeExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the FieldsDefinition field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceFieldsDefinition :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm Syntax.FieldsDefinition +interfaceTypeExtensionSequenceFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +interfaceTypeExtensionSequenceImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceInterfaceTypeExtensionSequence :: Typed.TypedName Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceInterfaceTypeExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence") + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceName :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm Syntax.Name +interfaceTypeExtensionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the FieldsDefinition field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithFieldsDefinition :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithImplementsInterfaces :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithName :: Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.InterfaceTypeExtensionSequence +interfaceTypeExtensionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.ListType wrapper +listType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ListType +listType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.ListType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ListType +listTypeListType :: Typed.TypedName Syntax.ListType +listTypeListType = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ListType") + +-- | DSL name token for hydra.ext.graphql.syntax.ListValue +listValueListValue :: Typed.TypedName Syntax.ListValue +listValueListValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ListValue") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.ListValue +listValueSeq :: Typed.TypedTerm Syntax.ListValueSequence -> Typed.TypedTerm Syntax.ListValue +listValueSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ListValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the sequence2 variant of hydra.ext.graphql.syntax.ListValue +listValueSequence2 :: Typed.TypedTerm [Syntax.Value] -> Typed.TypedTerm Syntax.ListValue +listValueSequence2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ListValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sequence2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.Name wrapper +name :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Name +name x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Name"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Name +nameName :: Typed.TypedName Syntax.Name +nameName = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Name") + +-- | DSL constructor for the hydra.ext.graphql.syntax.NamedType wrapper +namedType :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NamedType +namedType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.NamedType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.NamedType +namedTypeNamedType :: Typed.TypedName Syntax.NamedType +namedTypeNamedType = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.NamedType") + +-- | DSL injection for the list variant of hydra.ext.graphql.syntax.NonNullType +nonNullTypeList :: Typed.TypedTerm Syntax.ListType -> Typed.TypedTerm Syntax.NonNullType +nonNullTypeList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.NonNullType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the named variant of hydra.ext.graphql.syntax.NonNullType +nonNullTypeNamed :: Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.NonNullType +nonNullTypeNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.NonNullType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.NonNullType +nonNullTypeNonNullType :: Typed.TypedName Syntax.NonNullType +nonNullTypeNonNullType = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.NonNullType") + +-- | DSL constructor for the hydra.ext.graphql.syntax.NullValue wrapper +nullValue :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NullValue +nullValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.NullValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.NullValue +nullValueNullValue :: Typed.TypedName Syntax.NullValue +nullValueNullValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.NullValue") + +-- | DSL constructor for hydra.ext.graphql.syntax.ObjectField +objectField :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Value -> Typed.TypedTerm Syntax.ObjectField +objectField name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ObjectField +objectFieldName :: Typed.TypedTerm Syntax.ObjectField -> Typed.TypedTerm Syntax.Name +objectFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectField +objectFieldObjectField :: Typed.TypedName Syntax.ObjectField +objectFieldObjectField = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectField") + +-- | DSL accessor for the Value field of hydra.ext.graphql.syntax.ObjectField +objectFieldValue :: Typed.TypedTerm Syntax.ObjectField -> Typed.TypedTerm Syntax.Value +objectFieldValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.projectionFieldName = (Model.Name "Value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ObjectField +objectFieldWithName :: Typed.TypedTerm Syntax.ObjectField -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ObjectField +objectFieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.projectionFieldName = (Model.Name "Value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Value field of hydra.ext.graphql.syntax.ObjectField +objectFieldWithValue :: Typed.TypedTerm Syntax.ObjectField -> Typed.TypedTerm Syntax.Value -> Typed.TypedTerm Syntax.ObjectField +objectFieldWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectField"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm (Maybe Syntax.FieldsDefinition) -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinition description name implementsInterfaces directives fieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm fieldsDefinition)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionDescription :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +objectTypeDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionDirectives :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +objectTypeDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the FieldsDefinition field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionFieldsDefinition :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.FieldsDefinition) +objectTypeDefinitionFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +objectTypeDefinitionImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionName :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm Syntax.Name +objectTypeDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionObjectTypeDefinition :: Typed.TypedName Syntax.ObjectTypeDefinition +objectTypeDefinitionObjectTypeDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition") + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionWithDescription :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionWithDirectives :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the FieldsDefinition field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionWithFieldsDefinition :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.FieldsDefinition) -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinitionWithFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionWithImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinitionWithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ObjectTypeDefinition +objectTypeDefinitionWithName :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ObjectTypeDefinition +objectTypeDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectTypeExtension +objectTypeExtensionObjectTypeExtension :: Typed.TypedName Syntax.ObjectTypeExtension +objectTypeExtensionObjectTypeExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtension") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.ObjectTypeExtension +objectTypeExtensionSeq :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.ObjectTypeExtension +objectTypeExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.ObjectTypeExtension +objectTypeExtensionSeq2 :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.ObjectTypeExtension +objectTypeExtensionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq3 variant of hydra.ext.graphql.syntax.ObjectTypeExtension +objectTypeExtensionSeq3 :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 -> Typed.TypedTerm Syntax.ObjectTypeExtension +objectTypeExtensionSeq3 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq3"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequence :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequence name implementsInterfaces directives fieldsDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm fieldsDefinition)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2 name implementsInterfaces directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2Directives :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) +objectTypeExtensionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2ImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +objectTypeExtensionSequence2ImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2Name :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name +objectTypeExtensionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2ObjectTypeExtensionSequence2 :: Typed.TypedName Syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2ObjectTypeExtensionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithDirectives :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithName :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence2 +objectTypeExtensionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3 name implementsInterfaces = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm implementsInterfaces)}]})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3ImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 -> Typed.TypedTerm Syntax.ImplementsInterfaces +objectTypeExtensionSequence3ImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3Name :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 -> Typed.TypedTerm Syntax.Name +objectTypeExtensionSequence3Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3ObjectTypeExtensionSequence3 :: Typed.TypedName Syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3ObjectTypeExtensionSequence3 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3") + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3WithImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 -> Typed.TypedTerm Syntax.ImplementsInterfaces -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3WithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3WithName :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence3 +objectTypeExtensionSequence3WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceDirectives :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +objectTypeExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the FieldsDefinition field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceFieldsDefinition :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.FieldsDefinition +objectTypeExtensionSequenceFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) +objectTypeExtensionSequenceImplementsInterfaces x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceName :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.Name +objectTypeExtensionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceObjectTypeExtensionSequence :: Typed.TypedName Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceObjectTypeExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the FieldsDefinition field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithFieldsDefinition :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithFieldsDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ImplementsInterfaces field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithImplementsInterfaces :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.ImplementsInterfaces) -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithImplementsInterfaces original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithName :: Typed.TypedTerm Syntax.ObjectTypeExtensionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ObjectTypeExtensionSequence +objectTypeExtensionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ImplementsInterfaces"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "ImplementsInterfaces")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "FieldsDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "FieldsDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.ObjectValue +objectValueObjectValue :: Typed.TypedName Syntax.ObjectValue +objectValueObjectValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ObjectValue") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.ObjectValue +objectValueSeq :: Typed.TypedTerm Syntax.ObjectValueSequence -> Typed.TypedTerm Syntax.ObjectValue +objectValueSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the sequence2 variant of hydra.ext.graphql.syntax.ObjectValue +objectValueSequence2 :: Typed.TypedTerm [Syntax.ObjectField] -> Typed.TypedTerm Syntax.ObjectValue +objectValueSequence2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ObjectValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sequence2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.OperationDefinition +operationDefinitionOperationDefinition :: Typed.TypedName Syntax.OperationDefinition +operationDefinitionOperationDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.OperationDefinition") + +-- | DSL injection for the SelectionSet variant of hydra.ext.graphql.syntax.OperationDefinition +operationDefinitionSelectionSet :: Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.OperationDefinition +operationDefinitionSelectionSet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.OperationDefinition +operationDefinitionSeq :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm Syntax.OperationDefinition +operationDefinitionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequence :: Typed.TypedTerm Syntax.OperationType -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm (Maybe Syntax.VariablesDefinition) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequence operationType name variablesDefinition directives selectionSet = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Typed.unTypedTerm operationType)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm variablesDefinition)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm selectionSet)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceDirectives :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +operationDefinitionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceName :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Name) +operationDefinitionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceOperationDefinitionSequence :: Typed.TypedName Syntax.OperationDefinitionSequence +operationDefinitionSequenceOperationDefinitionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence") + +-- | DSL accessor for the OperationType field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceOperationType :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm Syntax.OperationType +operationDefinitionSequenceOperationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the SelectionSet field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceSelectionSet :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm Syntax.SelectionSet +operationDefinitionSequenceSelectionSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the VariablesDefinition field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceVariablesDefinition :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.VariablesDefinition) +operationDefinitionSequenceVariablesDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "VariablesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceWithDirectives :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "VariablesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceWithName :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "VariablesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the OperationType field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceWithOperationType :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm Syntax.OperationType -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequenceWithOperationType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "VariablesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the SelectionSet field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceWithSelectionSet :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequenceWithSelectionSet original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "VariablesDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the VariablesDefinition field of hydra.ext.graphql.syntax.OperationDefinitionSequence +operationDefinitionSequenceWithVariablesDefinition :: Typed.TypedTerm Syntax.OperationDefinitionSequence -> Typed.TypedTerm (Maybe Syntax.VariablesDefinition) -> Typed.TypedTerm Syntax.OperationDefinitionSequence +operationDefinitionSequenceWithVariablesDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "VariablesDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "SelectionSet"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence"), + Model.projectionFieldName = (Model.Name "SelectionSet")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the Mutation variant of hydra.ext.graphql.syntax.OperationType +operationTypeMutation :: Typed.TypedTerm Syntax.OperationType +operationTypeMutation = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Mutation"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.graphql.syntax.OperationType +operationTypeOperationType :: Typed.TypedName Syntax.OperationType +operationTypeOperationType = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.OperationType") + +-- | DSL injection for the Query variant of hydra.ext.graphql.syntax.OperationType +operationTypeQuery :: Typed.TypedTerm Syntax.OperationType +operationTypeQuery = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Query"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the Subscription variant of hydra.ext.graphql.syntax.OperationType +operationTypeSubscription :: Typed.TypedTerm Syntax.OperationType +operationTypeSubscription = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.OperationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Subscription"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinition :: Typed.TypedTerm Syntax.OperationType -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.RootOperationTypeDefinition +rootOperationTypeDefinition operationType namedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Typed.unTypedTerm operationType)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm namedType)}]})) + +-- | DSL accessor for the NamedType field of hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionNamedType :: Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.NamedType +rootOperationTypeDefinitionNamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the OperationType field of hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionOperationType :: Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.OperationType +rootOperationTypeDefinitionOperationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionRootOperationTypeDefinition :: Typed.TypedName Syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionRootOperationTypeDefinition = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition") + +-- | DSL updater for the NamedType field of hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionWithNamedType :: Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionWithNamedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.projectionFieldName = (Model.Name "OperationType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the OperationType field of hydra.ext.graphql.syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionWithOperationType :: Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.OperationType -> Typed.TypedTerm Syntax.RootOperationTypeDefinition +rootOperationTypeDefinitionWithOperationType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "OperationType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ScalarTypeDefinition +scalarTypeDefinition description name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionDescription :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +scalarTypeDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionDirectives :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +scalarTypeDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionName :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm Syntax.Name +scalarTypeDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionScalarTypeDefinition :: Typed.TypedName Syntax.ScalarTypeDefinition +scalarTypeDefinitionScalarTypeDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition") + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionWithDescription :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.ScalarTypeDefinition +scalarTypeDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionWithDirectives :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.ScalarTypeDefinition +scalarTypeDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ScalarTypeDefinition +scalarTypeDefinitionWithName :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ScalarTypeDefinition +scalarTypeDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtension :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.ScalarTypeExtension +scalarTypeExtension name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtensionDirectives :: Typed.TypedTerm Syntax.ScalarTypeExtension -> Typed.TypedTerm Syntax.Directives +scalarTypeExtensionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtensionName :: Typed.TypedTerm Syntax.ScalarTypeExtension -> Typed.TypedTerm Syntax.Name +scalarTypeExtensionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtensionScalarTypeExtension :: Typed.TypedName Syntax.ScalarTypeExtension +scalarTypeExtensionScalarTypeExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtensionWithDirectives :: Typed.TypedTerm Syntax.ScalarTypeExtension -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.ScalarTypeExtension +scalarTypeExtensionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.ScalarTypeExtension +scalarTypeExtensionWithName :: Typed.TypedTerm Syntax.ScalarTypeExtension -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ScalarTypeExtension +scalarTypeExtensionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.SchemaDefinition +schemaDefinition description directives rootOperationTypeDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Typed.unTypedTerm rootOperationTypeDefinition)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionDescription :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +schemaDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionDirectives :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +schemaDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the RootOperationTypeDefinition field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionRootOperationTypeDefinition :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm Syntax.RootOperationTypeDefinition +schemaDefinitionRootOperationTypeDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "RootOperationTypeDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionSchemaDefinition :: Typed.TypedName Syntax.SchemaDefinition +schemaDefinitionSchemaDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition") + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionWithDescription :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.SchemaDefinition +schemaDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "RootOperationTypeDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionWithDirectives :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.SchemaDefinition +schemaDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "RootOperationTypeDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the RootOperationTypeDefinition field of hydra.ext.graphql.syntax.SchemaDefinition +schemaDefinitionWithRootOperationTypeDefinition :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.SchemaDefinition +schemaDefinitionWithRootOperationTypeDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.SchemaExtension +schemaExtensionSchemaExtension :: Typed.TypedName Syntax.SchemaExtension +schemaExtensionSchemaExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.SchemaExtension") + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.SchemaExtension +schemaExtensionSeq :: Typed.TypedTerm Syntax.SchemaExtensionSequence -> Typed.TypedTerm Syntax.SchemaExtension +schemaExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequence :: Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.SchemaExtensionSequence +schemaExtensionSequence directives rootOperationTypeDefinition = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Typed.unTypedTerm rootOperationTypeDefinition)}]})) + +-- | DSL injection for the sequence2 variant of hydra.ext.graphql.syntax.SchemaExtension +schemaExtensionSequence2 :: Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.SchemaExtension +schemaExtensionSequence2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sequence2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequenceDirectives :: Typed.TypedTerm Syntax.SchemaExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +schemaExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the RootOperationTypeDefinition field of hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequenceRootOperationTypeDefinition :: Typed.TypedTerm Syntax.SchemaExtensionSequence -> Typed.TypedTerm Syntax.RootOperationTypeDefinition +schemaExtensionSequenceRootOperationTypeDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.projectionFieldName = (Model.Name "RootOperationTypeDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequenceSchemaExtensionSequence :: Typed.TypedName Syntax.SchemaExtensionSequence +schemaExtensionSequenceSchemaExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.SchemaExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.SchemaExtensionSequence +schemaExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.projectionFieldName = (Model.Name "RootOperationTypeDefinition")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the RootOperationTypeDefinition field of hydra.ext.graphql.syntax.SchemaExtensionSequence +schemaExtensionSequenceWithRootOperationTypeDefinition :: Typed.TypedTerm Syntax.SchemaExtensionSequence -> Typed.TypedTerm Syntax.RootOperationTypeDefinition -> Typed.TypedTerm Syntax.SchemaExtensionSequence +schemaExtensionSequenceWithRootOperationTypeDefinition original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "RootOperationTypeDefinition"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the Field variant of hydra.ext.graphql.syntax.Selection +selectionField :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Selection +selectionField x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Selection"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Field"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the FragmentSpread variant of hydra.ext.graphql.syntax.Selection +selectionFragmentSpread :: Typed.TypedTerm Syntax.FragmentSpread -> Typed.TypedTerm Syntax.Selection +selectionFragmentSpread x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Selection"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FragmentSpread"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the InlineFragment variant of hydra.ext.graphql.syntax.Selection +selectionInlineFragment :: Typed.TypedTerm Syntax.InlineFragment -> Typed.TypedTerm Syntax.Selection +selectionInlineFragment x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Selection"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "InlineFragment"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.Selection +selectionSelection :: Typed.TypedName Syntax.Selection +selectionSelection = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Selection") + +-- | DSL constructor for the hydra.ext.graphql.syntax.SelectionSet wrapper +selectionSet :: Typed.TypedTerm [Syntax.Selection] -> Typed.TypedTerm Syntax.SelectionSet +selectionSet x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.SelectionSet"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.SelectionSet +selectionSetSelectionSet :: Typed.TypedName Syntax.SelectionSet +selectionSetSelectionSet = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.SelectionSet") + +-- | DSL constructor for the hydra.ext.graphql.syntax.StringValue wrapper +stringValue :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.StringValue +stringValue x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.StringValue"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.StringValue +stringValueStringValue :: Typed.TypedName Syntax.StringValue +stringValueStringValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.StringValue") + +-- | DSL injection for the NamedType variant of hydra.ext.graphql.syntax.TypeCondition +typeConditionNamedType :: Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.TypeCondition +typeConditionNamedType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeCondition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the On variant of hydra.ext.graphql.syntax.TypeCondition +typeConditionOn :: Typed.TypedTerm Syntax.TypeCondition +typeConditionOn = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeCondition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "On"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeCondition +typeConditionTypeCondition :: Typed.TypedName Syntax.TypeCondition +typeConditionTypeCondition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeCondition") + +-- | DSL injection for the enum variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionEnum :: Typed.TypedTerm Syntax.EnumTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the inputObject variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionInputObject :: Typed.TypedTerm Syntax.InputObjectTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionInputObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inputObject"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interface variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionInterface :: Typed.TypedTerm Syntax.InterfaceTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionObject :: Typed.TypedTerm Syntax.ObjectTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the scalar variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionScalar :: Typed.TypedTerm Syntax.ScalarTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionScalar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "scalar"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionTypeDefinition :: Typed.TypedName Syntax.TypeDefinition +typeDefinitionTypeDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeDefinition") + +-- | DSL injection for the union variant of hydra.ext.graphql.syntax.TypeDefinition +typeDefinitionUnion :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm Syntax.TypeDefinition +typeDefinitionUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionEnum :: Typed.TypedTerm Syntax.EnumTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the inputObject variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionInputObject :: Typed.TypedTerm Syntax.InputObjectTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionInputObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inputObject"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interface variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionInterface :: Typed.TypedTerm Syntax.InterfaceTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionInterface x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interface"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionObject :: Typed.TypedTerm Syntax.ObjectTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the scalar variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionScalar :: Typed.TypedTerm Syntax.ScalarTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionScalar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "scalar"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeExtension +typeExtensionTypeExtension :: Typed.TypedName Syntax.TypeExtension +typeExtensionTypeExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeExtension") + +-- | DSL injection for the union variant of hydra.ext.graphql.syntax.TypeExtension +typeExtensionUnion :: Typed.TypedTerm Syntax.UnionTypeExtension -> Typed.TypedTerm Syntax.TypeExtension +typeExtensionUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the list variant of hydra.ext.graphql.syntax.Type +typeList :: Typed.TypedTerm Syntax.ListType -> Typed.TypedTerm Syntax.Type +typeList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the named variant of hydra.ext.graphql.syntax.Type +typeNamed :: Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.Type +typeNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nonNull variant of hydra.ext.graphql.syntax.Type +typeNonNull :: Typed.TypedTerm Syntax.NonNullType -> Typed.TypedTerm Syntax.Type +typeNonNull x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nonNull"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the directive variant of hydra.ext.graphql.syntax.TypeSystemDefinition +typeSystemDefinitionDirective :: Typed.TypedTerm Syntax.DirectiveDefinition -> Typed.TypedTerm Syntax.TypeSystemDefinition +typeSystemDefinitionDirective x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "directive"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the definition variant of hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionDefinition :: Typed.TypedTerm Syntax.TypeSystemDefinition -> Typed.TypedTerm Syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionDefinition x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "definition"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the extension variant of hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionExtension :: Typed.TypedTerm Syntax.TypeSystemExtension -> Typed.TypedTerm Syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionExtension x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extension"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionTypeSystemDefinitionOrExtension :: Typed.TypedName Syntax.TypeSystemDefinitionOrExtension +typeSystemDefinitionOrExtensionTypeSystemDefinitionOrExtension = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension") + +-- | DSL injection for the schema variant of hydra.ext.graphql.syntax.TypeSystemDefinition +typeSystemDefinitionSchema :: Typed.TypedTerm Syntax.SchemaDefinition -> Typed.TypedTerm Syntax.TypeSystemDefinition +typeSystemDefinitionSchema x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.graphql.syntax.TypeSystemDefinition +typeSystemDefinitionType :: Typed.TypedTerm Syntax.TypeDefinition -> Typed.TypedTerm Syntax.TypeSystemDefinition +typeSystemDefinitionType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemDefinition +typeSystemDefinitionTypeSystemDefinition :: Typed.TypedName Syntax.TypeSystemDefinition +typeSystemDefinitionTypeSystemDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinition") + +-- | DSL injection for the ARGUMENT_DEFINITION variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationARGUMENT_DEFINITION :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationARGUMENT_DEFINITION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ARGUMENT_DEFINITION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ENUM variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationENUM :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationENUM = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ENUM"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ENUM_VALUE variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationENUM_VALUE :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationENUM_VALUE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ENUM_VALUE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the FIELD_DEFINITION variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationFIELD_DEFINITION :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationFIELD_DEFINITION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FIELD_DEFINITION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the INPUT_FIELD_DEFINITION variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINPUT_FIELD_DEFINITION :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINPUT_FIELD_DEFINITION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "INPUT_FIELD_DEFINITION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the INPUT_OBJECT variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINPUT_OBJECT :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINPUT_OBJECT = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "INPUT_OBJECT"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the INTERFACE variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINTERFACE :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationINTERFACE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "INTERFACE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the OBJECT variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationOBJECT :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationOBJECT = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "OBJECT"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the SCALAR variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationSCALAR :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationSCALAR = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "SCALAR"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the SCHEMA variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationSCHEMA :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationSCHEMA = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "SCHEMA"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationTypeSystemDirectiveLocation :: Typed.TypedName Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationTypeSystemDirectiveLocation = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation") + +-- | DSL injection for the UNION variant of hydra.ext.graphql.syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationUNION :: Typed.TypedTerm Syntax.TypeSystemDirectiveLocation +typeSystemDirectiveLocationUNION = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "UNION"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.TypeSystemDocment wrapper +typeSystemDocment :: Typed.TypedTerm [Syntax.TypeSystemDefinition] -> Typed.TypedTerm Syntax.TypeSystemDocment +typeSystemDocment x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemDocment"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemDocment +typeSystemDocmentTypeSystemDocment :: Typed.TypedName Syntax.TypeSystemDocment +typeSystemDocmentTypeSystemDocment = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemDocment") + +-- | DSL constructor for the hydra.ext.graphql.syntax.TypeSystemExtensionDocument wrapper +typeSystemExtensionDocument :: Typed.TypedTerm [Syntax.TypeSystemDefinitionOrExtension] -> Typed.TypedTerm Syntax.TypeSystemExtensionDocument +typeSystemExtensionDocument x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtensionDocument"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemExtensionDocument +typeSystemExtensionDocumentTypeSystemExtensionDocument :: Typed.TypedName Syntax.TypeSystemExtensionDocument +typeSystemExtensionDocumentTypeSystemExtensionDocument = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtensionDocument") + +-- | DSL injection for the schema variant of hydra.ext.graphql.syntax.TypeSystemExtension +typeSystemExtensionSchema :: Typed.TypedTerm Syntax.SchemaExtension -> Typed.TypedTerm Syntax.TypeSystemExtension +typeSystemExtensionSchema x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.graphql.syntax.TypeSystemExtension +typeSystemExtensionType :: Typed.TypedTerm Syntax.TypeExtension -> Typed.TypedTerm Syntax.TypeSystemExtension +typeSystemExtensionType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.TypeSystemExtension +typeSystemExtensionTypeSystemExtension :: Typed.TypedName Syntax.TypeSystemExtension +typeSystemExtensionTypeSystemExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtension") + +-- | DSL name token for hydra.ext.graphql.syntax.Type +typeType :: Typed.TypedName Syntax.Type +typeType = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Type") + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Arguments +unArguments :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm [Syntax.Argument] +unArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Arguments")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.ArgumentsDefinition +unArgumentsDefinition :: Typed.TypedTerm Syntax.ArgumentsDefinition -> Typed.TypedTerm [Syntax.InputValueDefinition] +unArgumentsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.ArgumentsDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.DefaultValue +unDefaultValue :: Typed.TypedTerm Syntax.DefaultValue -> Typed.TypedTerm Syntax.Value +unDefaultValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.DefaultValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Description +unDescription :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.StringValue +unDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Description")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Directives +unDirectives :: Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm [Syntax.Directive] +unDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Directives")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Document +unDocument :: Typed.TypedTerm Syntax.Document -> Typed.TypedTerm [Syntax.Definition] +unDocument x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Document")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.EnumValue +unEnumValue :: Typed.TypedTerm Syntax.EnumValue -> Typed.TypedTerm Syntax.Name +unEnumValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.EnumValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.EnumValuesDefinition +unEnumValuesDefinition :: Typed.TypedTerm Syntax.EnumValuesDefinition -> Typed.TypedTerm [Syntax.EnumValueDefinition] +unEnumValuesDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.EnumValuesDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.ExecutableDocument +unExecutableDocument :: Typed.TypedTerm Syntax.ExecutableDocument -> Typed.TypedTerm [Syntax.ExecutableDefinition] +unExecutableDocument x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.ExecutableDocument")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.FieldsDefinition +unFieldsDefinition :: Typed.TypedTerm Syntax.FieldsDefinition -> Typed.TypedTerm [Syntax.FieldDefinition] +unFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.FieldsDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.FloatValue +unFloatValue :: Typed.TypedTerm Syntax.FloatValue -> Typed.TypedTerm String +unFloatValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.FloatValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.FragmentName +unFragmentName :: Typed.TypedTerm Syntax.FragmentName -> Typed.TypedTerm Syntax.Name +unFragmentName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.FragmentName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.InputFieldsDefinition +unInputFieldsDefinition :: Typed.TypedTerm Syntax.InputFieldsDefinition -> Typed.TypedTerm [Syntax.InputValueDefinition] +unInputFieldsDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.InputFieldsDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.IntValue +unIntValue :: Typed.TypedTerm Syntax.IntValue -> Typed.TypedTerm String +unIntValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.IntValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.ListType +unListType :: Typed.TypedTerm Syntax.ListType -> Typed.TypedTerm Syntax.Type +unListType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.ListType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Name +unName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm String +unName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Name")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.NamedType +unNamedType :: Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.Name +unNamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.NamedType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.NullValue +unNullValue :: Typed.TypedTerm Syntax.NullValue -> Typed.TypedTerm () +unNullValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.NullValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.SelectionSet +unSelectionSet :: Typed.TypedTerm Syntax.SelectionSet -> Typed.TypedTerm [Syntax.Selection] +unSelectionSet x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.SelectionSet")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.StringValue +unStringValue :: Typed.TypedTerm Syntax.StringValue -> Typed.TypedTerm String +unStringValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.StringValue")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.TypeSystemDocment +unTypeSystemDocment :: Typed.TypedTerm Syntax.TypeSystemDocment -> Typed.TypedTerm [Syntax.TypeSystemDefinition] +unTypeSystemDocment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.TypeSystemDocment")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.TypeSystemExtensionDocument +unTypeSystemExtensionDocument :: Typed.TypedTerm Syntax.TypeSystemExtensionDocument -> Typed.TypedTerm [Syntax.TypeSystemDefinitionOrExtension] +unTypeSystemExtensionDocument x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.TypeSystemExtensionDocument")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.graphql.syntax.Variable +unVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Name +unVariable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.graphql.syntax.Variable")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.UnionMemberTypes +unionMemberTypesSeq :: Typed.TypedTerm Syntax.UnionMemberTypesSequence -> Typed.TypedTerm Syntax.UnionMemberTypes +unionMemberTypesSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypes"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.UnionMemberTypes +unionMemberTypesSeq2 :: Typed.TypedTerm Syntax.UnionMemberTypesSequence2 -> Typed.TypedTerm Syntax.UnionMemberTypes +unionMemberTypesSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypes"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequence :: Typed.TypedTerm Syntax.UnionMemberTypes -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.UnionMemberTypesSequence +unionMemberTypesSequence unionMemberTypes namedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm unionMemberTypes)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm namedType)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2 :: Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2 or namedType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Typed.unTypedTerm or)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm namedType)}]})) + +-- | DSL accessor for the NamedType field of hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2NamedType :: Typed.TypedTerm Syntax.UnionMemberTypesSequence2 -> Typed.TypedTerm Syntax.NamedType +unionMemberTypesSequence2NamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Or field of hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2Or :: Typed.TypedTerm Syntax.UnionMemberTypesSequence2 -> Typed.TypedTerm (Maybe ()) +unionMemberTypesSequence2Or x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.projectionFieldName = (Model.Name "Or")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2UnionMemberTypesSequence2 :: Typed.TypedName Syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2UnionMemberTypesSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2") + +-- | DSL updater for the NamedType field of hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2WithNamedType :: Typed.TypedTerm Syntax.UnionMemberTypesSequence2 -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2WithNamedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.projectionFieldName = (Model.Name "Or")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Or field of hydra.ext.graphql.syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2WithOr :: Typed.TypedTerm Syntax.UnionMemberTypesSequence2 -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.UnionMemberTypesSequence2 +unionMemberTypesSequence2WithOr original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Or"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the NamedType field of hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequenceNamedType :: Typed.TypedTerm Syntax.UnionMemberTypesSequence -> Typed.TypedTerm Syntax.NamedType +unionMemberTypesSequenceNamedType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequenceUnionMemberTypes :: Typed.TypedTerm Syntax.UnionMemberTypesSequence -> Typed.TypedTerm Syntax.UnionMemberTypes +unionMemberTypesSequenceUnionMemberTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequenceUnionMemberTypesSequence :: Typed.TypedName Syntax.UnionMemberTypesSequence +unionMemberTypesSequenceUnionMemberTypesSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence") + +-- | DSL updater for the NamedType field of hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequenceWithNamedType :: Typed.TypedTerm Syntax.UnionMemberTypesSequence -> Typed.TypedTerm Syntax.NamedType -> Typed.TypedTerm Syntax.UnionMemberTypesSequence +unionMemberTypesSequenceWithNamedType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionMemberTypesSequence +unionMemberTypesSequenceWithUnionMemberTypes :: Typed.TypedTerm Syntax.UnionMemberTypesSequence -> Typed.TypedTerm Syntax.UnionMemberTypes -> Typed.TypedTerm Syntax.UnionMemberTypesSequence +unionMemberTypesSequenceWithUnionMemberTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "NamedType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence"), + Model.projectionFieldName = (Model.Name "NamedType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionMemberTypes +unionMemberTypesUnionMemberTypes :: Typed.TypedName Syntax.UnionMemberTypes +unionMemberTypesUnionMemberTypes = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionMemberTypes") + +-- | DSL constructor for hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinition :: Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm (Maybe Syntax.UnionMemberTypes) -> Typed.TypedTerm Syntax.UnionTypeDefinition +unionTypeDefinition description name directives unionMemberTypes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm unionMemberTypes)}]})) + +-- | DSL accessor for the Description field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionDescription :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) +unionTypeDefinitionDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionDirectives :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +unionTypeDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionName :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm Syntax.Name +unionTypeDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionUnionMemberTypes :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.UnionMemberTypes) +unionTypeDefinitionUnionMemberTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionUnionTypeDefinition :: Typed.TypedName Syntax.UnionTypeDefinition +unionTypeDefinitionUnionTypeDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition") + +-- | DSL updater for the Description field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionWithDescription :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Description) -> Typed.TypedTerm Syntax.UnionTypeDefinition +unionTypeDefinitionWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionWithDirectives :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.UnionTypeDefinition +unionTypeDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionWithName :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnionTypeDefinition +unionTypeDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionTypeDefinition +unionTypeDefinitionWithUnionMemberTypes :: Typed.TypedTerm Syntax.UnionTypeDefinition -> Typed.TypedTerm (Maybe Syntax.UnionMemberTypes) -> Typed.TypedTerm Syntax.UnionTypeDefinition +unionTypeDefinitionWithUnionMemberTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the seq variant of hydra.ext.graphql.syntax.UnionTypeExtension +unionTypeExtensionSeq :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm Syntax.UnionTypeExtension +unionTypeExtensionSeq x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the seq2 variant of hydra.ext.graphql.syntax.UnionTypeExtension +unionTypeExtensionSeq2 :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 -> Typed.TypedTerm Syntax.UnionTypeExtension +unionTypeExtensionSeq2 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtension"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "seq2"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequence :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.UnionMemberTypes -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence +unionTypeExtensionSequence name directives unionMemberTypes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm unionMemberTypes)}]})) + +-- | DSL constructor for hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2 name directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2Directives :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives +unionTypeExtensionSequence2Directives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2Name :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name +unionTypeExtensionSequence2Name x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2UnionTypeExtensionSequence2 :: Typed.TypedName Syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2UnionTypeExtensionSequence2 = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2WithDirectives :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Directives -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2WithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2WithName :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence2 +unionTypeExtensionSequence2WithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceDirectives :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) +unionTypeExtensionSequenceDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Name field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceName :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm Syntax.Name +unionTypeExtensionSequenceName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceUnionMemberTypes :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm Syntax.UnionMemberTypes +unionTypeExtensionSequenceUnionMemberTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceUnionTypeExtensionSequence :: Typed.TypedName Syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceUnionTypeExtensionSequence = + Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence") + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithDirectives :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Name field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithName :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "UnionMemberTypes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the UnionMemberTypes field of hydra.ext.graphql.syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithUnionMemberTypes :: Typed.TypedTerm Syntax.UnionTypeExtensionSequence -> Typed.TypedTerm Syntax.UnionMemberTypes -> Typed.TypedTerm Syntax.UnionTypeExtensionSequence +unionTypeExtensionSequenceWithUnionMemberTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "UnionMemberTypes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.graphql.syntax.UnionTypeExtension +unionTypeExtensionUnionTypeExtension :: Typed.TypedName Syntax.UnionTypeExtension +unionTypeExtensionUnionTypeExtension = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.UnionTypeExtension") + +-- | DSL injection for the boolean variant of hydra.ext.graphql.syntax.Value +valueBoolean :: Typed.TypedTerm Syntax.BooleanValue -> Typed.TypedTerm Syntax.Value +valueBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.graphql.syntax.Value +valueEnum :: Typed.TypedTerm Syntax.EnumValue -> Typed.TypedTerm Syntax.Value +valueEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the float variant of hydra.ext.graphql.syntax.Value +valueFloat :: Typed.TypedTerm Syntax.FloatValue -> Typed.TypedTerm Syntax.Value +valueFloat x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the int variant of hydra.ext.graphql.syntax.Value +valueInt :: Typed.TypedTerm Syntax.IntValue -> Typed.TypedTerm Syntax.Value +valueInt x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the list variant of hydra.ext.graphql.syntax.Value +valueList :: Typed.TypedTerm Syntax.ListValue -> Typed.TypedTerm Syntax.Value +valueList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the null variant of hydra.ext.graphql.syntax.Value +valueNull :: Typed.TypedTerm Syntax.NullValue -> Typed.TypedTerm Syntax.Value +valueNull x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.graphql.syntax.Value +valueObject :: Typed.TypedTerm Syntax.ObjectValue -> Typed.TypedTerm Syntax.Value +valueObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.graphql.syntax.Value +valueString :: Typed.TypedTerm Syntax.StringValue -> Typed.TypedTerm Syntax.Value +valueString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.graphql.syntax.Value +valueValue :: Typed.TypedName Syntax.Value +valueValue = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Value") + +-- | DSL injection for the Variable variant of hydra.ext.graphql.syntax.Value +valueVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Value +valueVariable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.graphql.syntax.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.graphql.syntax.Variable wrapper +variable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Variable +variable x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.graphql.syntax.Variable"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.Variable +variableVariable :: Typed.TypedName Syntax.Variable +variableVariable = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.Variable") + +-- | DSL constructor for hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinition :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.VariablesDefinition +variablesDefinition variable type_ defaultValue directives = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Typed.unTypedTerm variable)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Typed.unTypedTerm defaultValue)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm directives)}]})) + +-- | DSL accessor for the DefaultValue field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionDefaultValue :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm (Maybe Syntax.DefaultValue) +variablesDefinitionDefaultValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Directives field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionDirectives :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) +variablesDefinitionDirectives x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Type field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionType :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm Syntax.Type +variablesDefinitionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Variable field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionVariable :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm Syntax.Variable +variablesDefinitionVariable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Variable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionVariablesDefinition :: Typed.TypedName Syntax.VariablesDefinition +variablesDefinitionVariablesDefinition = Typed.TypedName (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition") + +-- | DSL updater for the DefaultValue field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionWithDefaultValue :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm Syntax.VariablesDefinition +variablesDefinitionWithDefaultValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Directives field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionWithDirectives :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm (Maybe Syntax.Directives) -> Typed.TypedTerm Syntax.VariablesDefinition +variablesDefinitionWithDirectives original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the Type field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionWithType :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VariablesDefinition +variablesDefinitionWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Variable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Variable field of hydra.ext.graphql.syntax.VariablesDefinition +variablesDefinitionWithVariable :: Typed.TypedTerm Syntax.VariablesDefinition -> Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.VariablesDefinition +variablesDefinitionWithVariable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Variable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "DefaultValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "DefaultValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Directives"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.graphql.syntax.VariablesDefinition"), + Model.projectionFieldName = (Model.Name "Directives")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Iana/Linkrelations.hs b/src/main/haskell/Hydra/Ext/Dsl/Iana/Linkrelations.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Iana/Linkrelations.hs @@ -0,0 +1,1105 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.iana.linkrelations + +module Hydra.Ext.Dsl.Iana.Linkrelations where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Iana.Linkrelations as Linkrelations +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL injection for the about variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAbout :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAbout = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "about"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the acl variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAcl :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAcl = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "acl"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the alternate variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAlternate :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAlternate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "alternate"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the amphtml variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAmphtml :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAmphtml = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "amphtml"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the appendix variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAppendix :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAppendix = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "appendix"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the apple-touch-icon variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeApple_touch_icon :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeApple_touch_icon = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "apple-touch-icon"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the apple-touch-startup-image variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeApple_touch_startup_image :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeApple_touch_startup_image = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "apple-touch-startup-image"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the archives variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeArchives :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeArchives = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "archives"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the author variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeAuthor :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeAuthor = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the blocked-by variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeBlocked_by :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeBlocked_by = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "blocked-by"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bookmark variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeBookmark :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeBookmark = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bookmark"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the canonical variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCanonical :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCanonical = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "canonical"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the chapter variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeChapter :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeChapter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "chapter"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the cite-as variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCite_as :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCite_as = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "cite-as"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the collection variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCollection :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCollection = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the contents variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeContents :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeContents = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "contents"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the convertedfrom variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeConvertedfrom :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeConvertedfrom = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "convertedfrom"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the copyright variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCopyright :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCopyright = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "copyright"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the create-form variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCreate_form :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCreate_form = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "create-form"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the current variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeCurrent :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeCurrent = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "current"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the describedby variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeDescribedby :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeDescribedby = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "describedby"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the describes variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeDescribes :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeDescribes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "describes"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the disclosure variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeDisclosure :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeDisclosure = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "disclosure"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dns-prefetch variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeDns_prefetch :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeDns_prefetch = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dns-prefetch"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the duplicate variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeDuplicate :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeDuplicate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "duplicate"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the edit variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeEdit :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeEdit = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "edit"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the edit-form variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeEdit_form :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeEdit_form = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "edit-form"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the edit-media variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeEdit_media :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeEdit_media = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "edit-media"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the enclosure variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeEnclosure :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeEnclosure = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enclosure"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the external variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeExternal :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeExternal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "external"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the first variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeFirst :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeFirst = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the glossary variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeGlossary :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeGlossary = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "glossary"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the help variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeHelp :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeHelp = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "help"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the hosts variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeHosts :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeHosts = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the hub variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeHub :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeHub = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hub"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the icon variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIcon :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIcon = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "icon"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the index variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIndex :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIndex = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalafter variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalafter :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalafter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalafter"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalbefore variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalbefore :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalbefore = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalbefore"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalcontains variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalcontains :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalcontains = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalcontains"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervaldisjoint variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervaldisjoint :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervaldisjoint = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervaldisjoint"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalduring variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalduring :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalduring = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalduring"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalequals variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalequals :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalequals = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalequals"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalfinishedby variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalfinishedby :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalfinishedby = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalfinishedby"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalfinishes variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalfinishes :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalfinishes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalfinishes"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalin variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalin :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalin = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalin"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalmeets variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalmeets :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalmeets = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalmeets"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalmetby variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalmetby :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalmetby = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalmetby"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervaloverlappedby variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervaloverlappedby :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervaloverlappedby = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervaloverlappedby"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervaloverlaps variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervaloverlaps :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervaloverlaps = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervaloverlaps"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalstartedby variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalstartedby :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalstartedby = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalstartedby"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the intervalstarts variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeIntervalstarts :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeIntervalstarts = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "intervalstarts"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the item variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeItem :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeItem = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "item"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the last variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLast :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeLast = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "last"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the latest-version variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLatest_version :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeLatest_version = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "latest-version"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the license variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLicense :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeLicense = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLinkRelationType :: Typed.TypedName Linkrelations.LinkRelationType +linkRelationTypeLinkRelationType = Typed.TypedName (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType") + +-- | DSL injection for the linkset variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLinkset :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeLinkset = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "linkset"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lrdd variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeLrdd :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeLrdd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lrdd"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the manifest variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeManifest :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeManifest = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "manifest"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the mask-icon variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMask_icon :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMask_icon = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "mask-icon"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the media-feed variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMedia_feed :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMedia_feed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "media-feed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the memento variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMemento :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMemento = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "memento"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the micropub variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMicropub :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMicropub = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "micropub"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the modulepreload variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeModulepreload :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeModulepreload = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "modulepreload"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the monitor variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMonitor :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMonitor = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "monitor"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the monitor-group variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeMonitor_group :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeMonitor_group = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "monitor-group"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the next variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeNext :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeNext = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "next"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the next-archive variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeNext_archive :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeNext_archive = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "next-archive"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the nofollow variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeNofollow :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeNofollow = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nofollow"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the noopener variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeNoopener :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeNoopener = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "noopener"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the noreferrer variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeNoreferrer :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeNoreferrer = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "noreferrer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the opener variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeOpener :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeOpener = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "opener"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the openid2.local_id variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeOpenid2Local_id :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeOpenid2Local_id = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "openid2.local_id"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the openid2.provider variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeOpenid2Provider :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeOpenid2Provider = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "openid2.provider"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the original variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeOriginal :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeOriginal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "original"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the p3pv1 variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeP3pv1 :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeP3pv1 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "p3pv1"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the payment variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePayment :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePayment = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "payment"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the pingback variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePingback :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePingback = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pingback"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preconnect variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePreconnect :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePreconnect = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preconnect"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the predecessor-version variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePredecessor_version :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePredecessor_version = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predecessor-version"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the prefetch variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrefetch :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrefetch = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "prefetch"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preload variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePreload :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePreload = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preload"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the prerender variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrerender :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrerender = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "prerender"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the prev variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrev :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrev = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "prev"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the prev-archive variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrev_archive :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrev_archive = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "prev-archive"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preview variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePreview :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePreview = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preview"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the previous variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrevious :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrevious = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "previous"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the privacy-policy variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePrivacy_policy :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePrivacy_policy = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "privacy-policy"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the profile variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeProfile :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeProfile = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "profile"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the publication variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypePublication :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypePublication = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "publication"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the related variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeRelated :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeRelated = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the replies variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeReplies :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeReplies = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "replies"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the restconf variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeRestconf :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeRestconf = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "restconf"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ruleinput variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeRuleinput :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeRuleinput = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ruleinput"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the search variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSearch :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSearch = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "search"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the section variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSection :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSection = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "section"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the self variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSelf :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSelf = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "self"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the service variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeService :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeService = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "service"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the service-desc variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeService_desc :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeService_desc = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "service-desc"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the service-doc variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeService_doc :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeService_doc = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "service-doc"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the service-meta variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeService_meta :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeService_meta = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "service-meta"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the siptrunkingcapability variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSiptrunkingcapability :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSiptrunkingcapability = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "siptrunkingcapability"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sponsored variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSponsored :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSponsored = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sponsored"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the start variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeStart :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeStart = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "start"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the status variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeStatus :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeStatus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the stylesheet variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeStylesheet :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeStylesheet = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "stylesheet"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the subsection variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSubsection :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSubsection = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subsection"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the successor-version variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSuccessor_version :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSuccessor_version = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "successor-version"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sunset variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeSunset :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeSunset = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sunset"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the tag variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeTag :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeTag = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "tag"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the terms-of-service variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeTerms_of_service :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeTerms_of_service = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "terms-of-service"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the timegate variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeTimegate :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeTimegate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timegate"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the timemap variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeTimemap :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeTimemap = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timemap"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the type variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeType :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeType = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ugc variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeUgc :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeUgc = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ugc"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the up variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeUp :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeUp = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "up"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the version-history variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeVersion_history :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeVersion_history = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "version-history"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the via variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeVia :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeVia = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "via"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the webmention variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeWebmention :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeWebmention = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "webmention"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the working-copy variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeWorking_copy :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeWorking_copy = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "working-copy"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the working-copy-of variant of hydra.ext.iana.linkrelations.LinkRelationType +linkRelationTypeWorking_copy_of :: Typed.TypedTerm Linkrelations.LinkRelationType +linkRelationTypeWorking_copy_of = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.iana.linkrelations.LinkRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "working-copy-of"), + Model.fieldTerm = Model.TermUnit}})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Json/Schema/Model.hs b/src/main/haskell/Hydra/Ext/Dsl/Json/Schema/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Json/Schema/Model.hs @@ -0,0 +1,741 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.json.schema.model + +module Hydra.Ext.Dsl.Json.Schema.Model where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Json.Schema.Model as SchemaModel +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL name token for hydra.ext.json.schema.model.AdditionalItems +additionalItemsAdditionalItems :: Typed.TypedName SchemaModel.AdditionalItems +additionalItemsAdditionalItems = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.AdditionalItems") + +-- | DSL injection for the any variant of hydra.ext.json.schema.model.AdditionalItems +additionalItemsAny :: Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.AdditionalItems +additionalItemsAny x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.AdditionalItems"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "any"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the schema variant of hydra.ext.json.schema.model.AdditionalItems +additionalItemsSchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.AdditionalItems +additionalItemsSchema x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.AdditionalItems"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the additionalItems variant of hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionAdditionalItems :: Typed.TypedTerm SchemaModel.AdditionalItems -> Typed.TypedTerm SchemaModel.ArrayRestriction +arrayRestrictionAdditionalItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "additionalItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionArrayRestriction :: Typed.TypedName SchemaModel.ArrayRestriction +arrayRestrictionArrayRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.ArrayRestriction") + +-- | DSL injection for the items variant of hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionItems :: Typed.TypedTerm SchemaModel.Items -> Typed.TypedTerm SchemaModel.ArrayRestriction +arrayRestrictionItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "items"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the maxItems variant of hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionMaxItems :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ArrayRestriction +arrayRestrictionMaxItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "maxItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the minItems variant of hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionMinItems :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ArrayRestriction +arrayRestrictionMinItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the uniqueItems variant of hydra.ext.json.schema.model.ArrayRestriction +arrayRestrictionUniqueItems :: Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.ArrayRestriction +arrayRestrictionUniqueItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uniqueItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.json.schema.model.Document +document :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema)) -> Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Document +document id definitions root = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Typed.unTypedTerm definitions)}, + Model.Field { + Model.fieldName = (Model.Name "root"), + Model.fieldTerm = (Typed.unTypedTerm root)}]})) + +-- | DSL accessor for the definitions field of hydra.ext.json.schema.model.Document +documentDefinitions :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema)) +documentDefinitions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.json.schema.model.Document +documentDocument :: Typed.TypedName SchemaModel.Document +documentDocument = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Document") + +-- | DSL accessor for the id field of hydra.ext.json.schema.model.Document +documentId :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe String) +documentId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the root field of hydra.ext.json.schema.model.Document +documentRoot :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm SchemaModel.Schema +documentRoot x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "root")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the definitions field of hydra.ext.json.schema.model.Document +documentWithDefinitions :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema)) -> Typed.TypedTerm SchemaModel.Document +documentWithDefinitions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "root"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "root")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.json.schema.model.Document +documentWithId :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm SchemaModel.Document +documentWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "root"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "root")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the root field of hydra.ext.json.schema.model.Document +documentWithRoot :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Document +documentWithRoot original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "root"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.json.schema.model.Items +itemsItems :: Typed.TypedName SchemaModel.Items +itemsItems = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Items") + +-- | DSL injection for the sameItems variant of hydra.ext.json.schema.model.Items +itemsSameItems :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Items +itemsSameItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Items"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sameItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the varItems variant of hydra.ext.json.schema.model.Items +itemsVarItems :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.Items +itemsVarItems x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Items"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "varItems"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.json.schema.model.Keyword wrapper +keyword :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Keyword +keyword x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.Keyword"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.json.schema.model.Keyword +keywordKeyword :: Typed.TypedName SchemaModel.Keyword +keywordKeyword = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Keyword") + +-- | DSL constructor for hydra.ext.json.schema.model.Limit +limit :: Typed.TypedTerm Int -> Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.Limit +limit value exclusive = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "exclusive"), + Model.fieldTerm = (Typed.unTypedTerm exclusive)}]})) + +-- | DSL accessor for the exclusive field of hydra.ext.json.schema.model.Limit +limitExclusive :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Bool +limitExclusive x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.projectionFieldName = (Model.Name "exclusive")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.json.schema.model.Limit +limitLimit :: Typed.TypedName SchemaModel.Limit +limitLimit = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Limit") + +-- | DSL accessor for the value field of hydra.ext.json.schema.model.Limit +limitValue :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Int +limitValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the exclusive field of hydra.ext.json.schema.model.Limit +limitWithExclusive :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.Limit +limitWithExclusive original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "exclusive"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the value field of hydra.ext.json.schema.model.Limit +limitWithValue :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.Limit +limitWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "exclusive"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"), + Model.projectionFieldName = (Model.Name "exclusive")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the allOf variant of hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionAllOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction +multipleRestrictionAllOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "allOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the anyOf variant of hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionAnyOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction +multipleRestrictionAnyOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "anyOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionEnum :: Typed.TypedTerm [JsonModel.Value] -> Typed.TypedTerm SchemaModel.MultipleRestriction +multipleRestrictionEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionMultipleRestriction :: Typed.TypedName SchemaModel.MultipleRestriction +multipleRestrictionMultipleRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.MultipleRestriction") + +-- | DSL injection for the not variant of hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionNot :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.MultipleRestriction +multipleRestrictionNot x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the oneOf variant of hydra.ext.json.schema.model.MultipleRestriction +multipleRestrictionOneOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction +multipleRestrictionOneOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "oneOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the maximum variant of hydra.ext.json.schema.model.NumericRestriction +numericRestrictionMaximum :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm SchemaModel.NumericRestriction +numericRestrictionMaximum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "maximum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the minimum variant of hydra.ext.json.schema.model.NumericRestriction +numericRestrictionMinimum :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm SchemaModel.NumericRestriction +numericRestrictionMinimum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minimum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multipleOf variant of hydra.ext.json.schema.model.NumericRestriction +numericRestrictionMultipleOf :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.NumericRestriction +numericRestrictionMultipleOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multipleOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.NumericRestriction +numericRestrictionNumericRestriction :: Typed.TypedName SchemaModel.NumericRestriction +numericRestrictionNumericRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.NumericRestriction") + +-- | DSL injection for the additionalProperties variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionAdditionalProperties :: Typed.TypedTerm SchemaModel.AdditionalItems -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionAdditionalProperties x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "additionalProperties"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the dependencies variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionDependencies :: Typed.TypedTerm (M.Map SchemaModel.Keyword SchemaModel.SchemaOrArray) -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionDependencies x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the maxProperties variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionMaxProperties :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionMaxProperties x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "maxProperties"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the minProperties variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionMinProperties :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionMinProperties x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minProperties"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionObjectRestriction :: Typed.TypedName SchemaModel.ObjectRestriction +objectRestrictionObjectRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.ObjectRestriction") + +-- | DSL injection for the patternProperties variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionPatternProperties :: Typed.TypedTerm (M.Map SchemaModel.RegularExpression SchemaModel.Schema) -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionPatternProperties x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "patternProperties"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the properties variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionProperties :: Typed.TypedTerm (M.Map SchemaModel.Keyword SchemaModel.Schema) -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionProperties x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "properties"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the required variant of hydra.ext.json.schema.model.ObjectRestriction +objectRestrictionRequired :: Typed.TypedTerm [SchemaModel.Keyword] -> Typed.TypedTerm SchemaModel.ObjectRestriction +objectRestrictionRequired x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "required"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.json.schema.model.RegularExpression wrapper +regularExpression :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.RegularExpression +regularExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.RegularExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.json.schema.model.RegularExpression +regularExpressionRegularExpression :: Typed.TypedName SchemaModel.RegularExpression +regularExpressionRegularExpression = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.RegularExpression") + +-- | DSL injection for the array variant of hydra.ext.json.schema.model.Restriction +restrictionArray :: Typed.TypedTerm SchemaModel.ArrayRestriction -> Typed.TypedTerm SchemaModel.Restriction +restrictionArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the description variant of hydra.ext.json.schema.model.Restriction +restrictionDescription :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Restriction +restrictionDescription x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multiple variant of hydra.ext.json.schema.model.Restriction +restrictionMultiple :: Typed.TypedTerm SchemaModel.MultipleRestriction -> Typed.TypedTerm SchemaModel.Restriction +restrictionMultiple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the number variant of hydra.ext.json.schema.model.Restriction +restrictionNumber :: Typed.TypedTerm SchemaModel.NumericRestriction -> Typed.TypedTerm SchemaModel.Restriction +restrictionNumber x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the object variant of hydra.ext.json.schema.model.Restriction +restrictionObject :: Typed.TypedTerm SchemaModel.ObjectRestriction -> Typed.TypedTerm SchemaModel.Restriction +restrictionObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the reference variant of hydra.ext.json.schema.model.Restriction +restrictionReference :: Typed.TypedTerm SchemaModel.SchemaReference -> Typed.TypedTerm SchemaModel.Restriction +restrictionReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.Restriction +restrictionRestriction :: Typed.TypedName SchemaModel.Restriction +restrictionRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Restriction") + +-- | DSL injection for the string variant of hydra.ext.json.schema.model.Restriction +restrictionString :: Typed.TypedTerm SchemaModel.StringRestriction -> Typed.TypedTerm SchemaModel.Restriction +restrictionString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the title variant of hydra.ext.json.schema.model.Restriction +restrictionTitle :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Restriction +restrictionTitle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the type variant of hydra.ext.json.schema.model.Restriction +restrictionType :: Typed.TypedTerm SchemaModel.Type -> Typed.TypedTerm SchemaModel.Restriction +restrictionType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.json.schema.model.Schema wrapper +schema :: Typed.TypedTerm [SchemaModel.Restriction] -> Typed.TypedTerm SchemaModel.Schema +schema x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.Schema"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL injection for the array variant of hydra.ext.json.schema.model.SchemaOrArray +schemaOrArrayArray :: Typed.TypedTerm [SchemaModel.Keyword] -> Typed.TypedTerm SchemaModel.SchemaOrArray +schemaOrArrayArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaOrArray"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the schema variant of hydra.ext.json.schema.model.SchemaOrArray +schemaOrArraySchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.SchemaOrArray +schemaOrArraySchema x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaOrArray"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.SchemaOrArray +schemaOrArraySchemaOrArray :: Typed.TypedName SchemaModel.SchemaOrArray +schemaOrArraySchemaOrArray = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.SchemaOrArray") + +-- | DSL constructor for the hydra.ext.json.schema.model.SchemaReference wrapper +schemaReference :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.SchemaReference +schemaReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.json.schema.model.SchemaReference +schemaReferenceSchemaReference :: Typed.TypedName SchemaModel.SchemaReference +schemaReferenceSchemaReference = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.SchemaReference") + +-- | DSL name token for hydra.ext.json.schema.model.Schema +schemaSchema :: Typed.TypedName SchemaModel.Schema +schemaSchema = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Schema") + +-- | DSL injection for the maxLength variant of hydra.ext.json.schema.model.StringRestriction +stringRestrictionMaxLength :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.StringRestriction +stringRestrictionMaxLength x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "maxLength"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the minLength variant of hydra.ext.json.schema.model.StringRestriction +stringRestrictionMinLength :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.StringRestriction +stringRestrictionMinLength x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minLength"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pattern variant of hydra.ext.json.schema.model.StringRestriction +stringRestrictionPattern :: Typed.TypedTerm SchemaModel.RegularExpression -> Typed.TypedTerm SchemaModel.StringRestriction +stringRestrictionPattern x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.StringRestriction +stringRestrictionStringRestriction :: Typed.TypedName SchemaModel.StringRestriction +stringRestrictionStringRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.StringRestriction") + +-- | DSL injection for the multiple variant of hydra.ext.json.schema.model.Type +typeMultiple :: Typed.TypedTerm [SchemaModel.TypeName] -> Typed.TypedTerm SchemaModel.Type +typeMultiple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the array variant of hydra.ext.json.schema.model.TypeName +typeNameArray :: Typed.TypedTerm SchemaModel.TypeName +typeNameArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the boolean variant of hydra.ext.json.schema.model.TypeName +typeNameBoolean :: Typed.TypedTerm SchemaModel.TypeName +typeNameBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the integer variant of hydra.ext.json.schema.model.TypeName +typeNameInteger :: Typed.TypedTerm SchemaModel.TypeName +typeNameInteger = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the null variant of hydra.ext.json.schema.model.TypeName +typeNameNull :: Typed.TypedTerm SchemaModel.TypeName +typeNameNull = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the number variant of hydra.ext.json.schema.model.TypeName +typeNameNumber :: Typed.TypedTerm SchemaModel.TypeName +typeNameNumber = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the object variant of hydra.ext.json.schema.model.TypeName +typeNameObject :: Typed.TypedTerm SchemaModel.TypeName +typeNameObject = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "object"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.json.schema.model.TypeName +typeNameString :: Typed.TypedTerm SchemaModel.TypeName +typeNameString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.json.schema.model.TypeName +typeNameTypeName :: Typed.TypedName SchemaModel.TypeName +typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.TypeName") + +-- | DSL injection for the single variant of hydra.ext.json.schema.model.Type +typeSingle :: Typed.TypedTerm SchemaModel.TypeName -> Typed.TypedTerm SchemaModel.Type +typeSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.json.schema.model.Type +typeType :: Typed.TypedName SchemaModel.Type +typeType = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Type") + +-- | DSL accessor for the body of hydra.ext.json.schema.model.Keyword +unKeyword :: Typed.TypedTerm SchemaModel.Keyword -> Typed.TypedTerm String +unKeyword x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.Keyword")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.json.schema.model.RegularExpression +unRegularExpression :: Typed.TypedTerm SchemaModel.RegularExpression -> Typed.TypedTerm String +unRegularExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.RegularExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.json.schema.model.Schema +unSchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm [SchemaModel.Restriction] +unSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.Schema")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.json.schema.model.SchemaReference +unSchemaReference :: Typed.TypedTerm SchemaModel.SchemaReference -> Typed.TypedTerm String +unSchemaReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.SchemaReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Kusto/Kql.hs b/src/main/haskell/Hydra/Ext/Dsl/Kusto/Kql.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Kusto/Kql.hs @@ -0,0 +1,2970 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.kusto.kql + +module Hydra.Ext.Dsl.Kusto.Kql where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Kusto.Kql as Kql +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Int as I + +-- | DSL constructor for hydra.ext.kusto.kql.BetweenExpression +betweenExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression +betweenExpression not expression lowerBound upperBound = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Typed.unTypedTerm not)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "lowerBound"), + Model.fieldTerm = (Typed.unTypedTerm lowerBound)}, + Model.Field { + Model.fieldName = (Model.Name "upperBound"), + Model.fieldTerm = (Typed.unTypedTerm upperBound)}]})) + +-- | DSL name token for hydra.ext.kusto.kql.BetweenExpression +betweenExpressionBetweenExpression :: Typed.TypedName Kql.BetweenExpression +betweenExpressionBetweenExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BetweenExpression") + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionExpression :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression +betweenExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the lowerBound field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionLowerBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression +betweenExpressionLowerBound x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "lowerBound")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the not field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionNot :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Bool +betweenExpressionNot x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "not")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the upperBound field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionUpperBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression +betweenExpressionUpperBound x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "upperBound")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionWithExpression :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression +betweenExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "not")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "lowerBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "lowerBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "upperBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "upperBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the lowerBound field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionWithLowerBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression +betweenExpressionWithLowerBound original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "not")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "lowerBound"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "upperBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "upperBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the not field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionWithNot :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Kql.BetweenExpression +betweenExpressionWithNot original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "lowerBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "lowerBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "upperBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "upperBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the upperBound field of hydra.ext.kusto.kql.BetweenExpression +betweenExpressionWithUpperBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression +betweenExpressionWithUpperBound original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "not")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "lowerBound"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"), + Model.projectionFieldName = (Model.Name "lowerBound")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "upperBound"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.BinaryExpression +binaryExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryOperator -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression +binaryExpression left operator right = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm left)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm right)}]})) + +-- | DSL name token for hydra.ext.kusto.kql.BinaryExpression +binaryExpressionBinaryExpression :: Typed.TypedName Kql.BinaryExpression +binaryExpressionBinaryExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BinaryExpression") + +-- | DSL accessor for the left field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionLeft :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression +binaryExpressionLeft x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionOperator :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.BinaryOperator +binaryExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the right field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionRight :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression +binaryExpressionRight x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the left field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionWithLeft :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression +binaryExpressionWithLeft original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the operator field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionWithOperator :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.BinaryOperator -> Typed.TypedTerm Kql.BinaryExpression +binaryExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "right")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the right field of hydra.ext.kusto.kql.BinaryExpression +binaryExpressionWithRight :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression +binaryExpressionWithRight original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "left"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "left")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "right"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.kusto.kql.BinaryOperator +binaryOperatorBinaryOperator :: Typed.TypedName Kql.BinaryOperator +binaryOperatorBinaryOperator = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BinaryOperator") + +-- | DSL injection for the caseInsensitiveEqual variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorCaseInsensitiveEqual :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorCaseInsensitiveEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "caseInsensitiveEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the contains variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorContains :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorContains = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "contains"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the divide variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorDivide :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorDivide = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "divide"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the endsWith variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorEndsWith :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorEndsWith = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "endsWith"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the equal variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorEqual :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "equal"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greater variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorGreater :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorGreater = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greater"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the greaterOrEqual variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorGreaterOrEqual :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorGreaterOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "greaterOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the has variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorHas :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorHas = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "has"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the hasPrefix variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorHasPrefix :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorHasPrefix = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hasPrefix"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the hasSuffix variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorHasSuffix :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorHasSuffix = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hasSuffix"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the less variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorLess :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorLess = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "less"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lessOrEqual variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorLessOrEqual :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorLessOrEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lessOrEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the matchesRegex variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorMatchesRegex :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorMatchesRegex = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "matchesRegex"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minus variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorMinus :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorMinus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the notEqual variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorNotEqual :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorNotEqual = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "notEqual"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the plus variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorPlus :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorPlus = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plus"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the startsWith variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorStartsWith :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorStartsWith = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "startsWith"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the times variant of hydra.ext.kusto.kql.BinaryOperator +binaryOperatorTimes :: Typed.TypedTerm Kql.BinaryOperator +binaryOperatorTimes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "times"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the ago variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionAgo :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionAgo = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ago"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bin variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionBin :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionBin = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bin"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionBuiltInFunction :: Typed.TypedName Kql.BuiltInFunction +builtInFunctionBuiltInFunction = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BuiltInFunction") + +-- | DSL injection for the count variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionCount :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionCount = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dcount variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionDcount :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionDcount = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dcount"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the endofday variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionEndofday :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionEndofday = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "endofday"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the extract variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionExtract :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionExtract = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extract"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the format_datetime variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionFormat_datetime :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionFormat_datetime = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "format_datetime"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the materialize variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionMaterialize :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionMaterialize = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "materialize"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the now variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionNow :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionNow = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "now"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the range variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionRange :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionRange = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "range"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the startofday variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionStartofday :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionStartofday = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "startofday"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the strcat variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionStrcat :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionStrcat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "strcat"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the todynamic variant of hydra.ext.kusto.kql.BuiltInFunction +builtInFunctionTodynamic :: Typed.TypedTerm Kql.BuiltInFunction +builtInFunctionTodynamic = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "todynamic"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.kusto.kql.ColumnAlias +columnAlias :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias +columnAlias column alias = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm column)}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}]})) + +-- | DSL accessor for the alias field of hydra.ext.kusto.kql.ColumnAlias +columnAliasAlias :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName +columnAliasAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the column field of hydra.ext.kusto.kql.ColumnAlias +columnAliasColumn :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName +columnAliasColumn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.ColumnAlias +columnAliasColumnAlias :: Typed.TypedName Kql.ColumnAlias +columnAliasColumnAlias = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnAlias") + +-- | DSL updater for the alias field of hydra.ext.kusto.kql.ColumnAlias +columnAliasWithAlias :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias +columnAliasWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the column field of hydra.ext.kusto.kql.ColumnAlias +columnAliasWithColumn :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias +columnAliasWithColumn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.ColumnAssignment +columnAssignment :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.ColumnAssignment +columnAssignment column expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm column)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the column field of hydra.ext.kusto.kql.ColumnAssignment +columnAssignmentColumn :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.ColumnName +columnAssignmentColumn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.ColumnAssignment +columnAssignmentColumnAssignment :: Typed.TypedName Kql.ColumnAssignment +columnAssignmentColumnAssignment = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnAssignment") + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.ColumnAssignment +columnAssignmentExpression :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.Expression +columnAssignmentExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the column field of hydra.ext.kusto.kql.ColumnAssignment +columnAssignmentWithColumn :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAssignment +columnAssignmentWithColumn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.ColumnAssignment +columnAssignmentWithExpression :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.ColumnAssignment +columnAssignmentWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.kusto.kql.ColumnName wrapper +columnName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.ColumnName +columnName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.ColumnName +columnNameColumnName :: Typed.TypedName Kql.ColumnName +columnNameColumnName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnName") + +-- | DSL injection for the all variant of hydra.ext.kusto.kql.Columns +columnsAll :: Typed.TypedTerm Kql.Columns +columnsAll = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Columns"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "all"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.Columns +columnsColumns :: Typed.TypedName Kql.Columns +columnsColumns = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Columns") + +-- | DSL injection for the single variant of hydra.ext.kusto.kql.Columns +columnsSingle :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Columns +columnsSingle x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Columns"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "single"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.kusto.kql.Command +commandCommand :: Typed.TypedName Kql.Command +commandCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Command") + +-- | DSL injection for the count variant of hydra.ext.kusto.kql.Command +commandCount :: Typed.TypedTerm Kql.Command +commandCount = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the distinct variant of hydra.ext.kusto.kql.Command +commandDistinct :: Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.Command +commandDistinct x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "distinct"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the extend variant of hydra.ext.kusto.kql.Command +commandExtend :: Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm Kql.Command +commandExtend x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "extend"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the join variant of hydra.ext.kusto.kql.Command +commandJoin :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Command +commandJoin x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "join"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the limit variant of hydra.ext.kusto.kql.Command +commandLimit :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Command +commandLimit x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "limit"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the mvexpand variant of hydra.ext.kusto.kql.Command +commandMvexpand :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Command +commandMvexpand x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "mvexpand"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the orderBy variant of hydra.ext.kusto.kql.Command +commandOrderBy :: Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.Command +commandOrderBy x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "orderBy"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parse variant of hydra.ext.kusto.kql.Command +commandParse :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.Command +commandParse x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parse"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the print variant of hydra.ext.kusto.kql.Command +commandPrint :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Command +commandPrint x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "print"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the project variant of hydra.ext.kusto.kql.Command +commandProject :: Typed.TypedTerm [Kql.Projection] -> Typed.TypedTerm Kql.Command +commandProject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "project"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the projectAway variant of hydra.ext.kusto.kql.Command +commandProjectAway :: Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.Command +commandProjectAway x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "projectAway"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the projectRename variant of hydra.ext.kusto.kql.Command +commandProjectRename :: Typed.TypedTerm [Kql.ColumnAlias] -> Typed.TypedTerm Kql.Command +commandProjectRename x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "projectRename"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the render variant of hydra.ext.kusto.kql.Command +commandRender :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Command +commandRender x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "render"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the search variant of hydra.ext.kusto.kql.Command +commandSearch :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Command +commandSearch x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "search"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the sortBy variant of hydra.ext.kusto.kql.Command +commandSortBy :: Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.Command +commandSortBy x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sortBy"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the summarize variant of hydra.ext.kusto.kql.Command +commandSummarize :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm Kql.Command +commandSummarize x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "summarize"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the take variant of hydra.ext.kusto.kql.Command +commandTake :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Command +commandTake x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "take"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the top variant of hydra.ext.kusto.kql.Command +commandTop :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Kql.Command +commandTop x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "top"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the union variant of hydra.ext.kusto.kql.Command +commandUnion :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm Kql.Command +commandUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the where variant of hydra.ext.kusto.kql.Command +commandWhere :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Command +commandWhere x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "where"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.kusto.kql.Datetime wrapper +datetime :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Datetime +datetime x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.Datetime"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.Datetime +datetimeDatetime :: Typed.TypedName Kql.Datetime +datetimeDatetime = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Datetime") + +-- | DSL constructor for hydra.ext.kusto.kql.Duration +duration :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.DurationUnit -> Typed.TypedTerm Kql.Duration +duration value unit = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm unit)}]})) + +-- | DSL name token for hydra.ext.kusto.kql.Duration +durationDuration :: Typed.TypedName Kql.Duration +durationDuration = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Duration") + +-- | DSL accessor for the unit field of hydra.ext.kusto.kql.Duration +durationUnit :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.DurationUnit +durationUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.DurationUnit +durationUnitDurationUnit :: Typed.TypedName Kql.DurationUnit +durationUnitDurationUnit = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.DurationUnit") + +-- | DSL injection for the hour variant of hydra.ext.kusto.kql.DurationUnit +durationUnitHour :: Typed.TypedTerm Kql.DurationUnit +durationUnitHour = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hour"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the minute variant of hydra.ext.kusto.kql.DurationUnit +durationUnitMinute :: Typed.TypedTerm Kql.DurationUnit +durationUnitMinute = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "minute"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the second variant of hydra.ext.kusto.kql.DurationUnit +durationUnitSecond :: Typed.TypedTerm Kql.DurationUnit +durationUnitSecond = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "second"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the value field of hydra.ext.kusto.kql.Duration +durationValue :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Int +durationValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the unit field of hydra.ext.kusto.kql.Duration +durationWithUnit :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.DurationUnit -> Typed.TypedTerm Kql.Duration +durationWithUnit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the value field of hydra.ext.kusto.kql.Duration +durationWithValue :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Int -> Typed.TypedTerm Kql.Duration +durationWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the and variant of hydra.ext.kusto.kql.Expression +expressionAnd :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression +expressionAnd x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "and"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the any variant of hydra.ext.kusto.kql.Expression +expressionAny :: Typed.TypedTerm Kql.Expression +expressionAny = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "any"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the between variant of hydra.ext.kusto.kql.Expression +expressionBetween :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression +expressionBetween x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "between"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the binary variant of hydra.ext.kusto.kql.Expression +expressionBinary :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression +expressionBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the braces variant of hydra.ext.kusto.kql.Expression +expressionBraces :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression +expressionBraces x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "braces"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the column variant of hydra.ext.kusto.kql.Expression +expressionColumn :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression +expressionColumn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the dataset variant of hydra.ext.kusto.kql.Expression +expressionDataset :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.Expression +expressionDataset x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dataset"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.kusto.kql.Expression +expressionExpression :: Typed.TypedName Kql.Expression +expressionExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Expression") + +-- | DSL injection for the index variant of hydra.ext.kusto.kql.Expression +expressionIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression +expressionIndex x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the list variant of hydra.ext.kusto.kql.Expression +expressionList :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression +expressionList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the literal variant of hydra.ext.kusto.kql.Expression +expressionLiteral :: Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Expression +expressionLiteral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "literal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the or variant of hydra.ext.kusto.kql.Expression +expressionOr :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression +expressionOr x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "or"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parentheses variant of hydra.ext.kusto.kql.Expression +expressionParentheses :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression +expressionParentheses x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parentheses"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the property variant of hydra.ext.kusto.kql.Expression +expressionProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression +expressionProperty x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unary variant of hydra.ext.kusto.kql.Expression +expressionUnary :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression +expressionUnary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the builtIn variant of hydra.ext.kusto.kql.Function +functionBuiltIn :: Typed.TypedTerm Kql.BuiltInFunction -> Typed.TypedTerm Kql.Function +functionBuiltIn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Function"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "builtIn"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the custom variant of hydra.ext.kusto.kql.Function +functionCustom :: Typed.TypedTerm Kql.FunctionName -> Typed.TypedTerm Kql.Function +functionCustom x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Function"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "custom"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.kusto.kql.FunctionExpression +functionExpression :: Typed.TypedTerm Kql.Function -> Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.FunctionExpression +functionExpression function arguments = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm function)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm arguments)}]})) + +-- | DSL accessor for the arguments field of hydra.ext.kusto.kql.FunctionExpression +functionExpressionArguments :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm [Kql.Expression] +functionExpressionArguments x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the function field of hydra.ext.kusto.kql.FunctionExpression +functionExpressionFunction :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm Kql.Function +functionExpressionFunction x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.FunctionExpression +functionExpressionFunctionExpression :: Typed.TypedName Kql.FunctionExpression +functionExpressionFunctionExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.FunctionExpression") + +-- | DSL updater for the arguments field of hydra.ext.kusto.kql.FunctionExpression +functionExpressionWithArguments :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.FunctionExpression +functionExpressionWithArguments original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.projectionFieldName = (Model.Name "function")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the function field of hydra.ext.kusto.kql.FunctionExpression +functionExpressionWithFunction :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm Kql.Function -> Typed.TypedTerm Kql.FunctionExpression +functionExpressionWithFunction original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "function"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "arguments"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"), + Model.projectionFieldName = (Model.Name "arguments")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.kusto.kql.Function +functionFunction :: Typed.TypedName Kql.Function +functionFunction = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Function") + +-- | DSL constructor for the hydra.ext.kusto.kql.FunctionName wrapper +functionName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.FunctionName +functionName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.FunctionName +functionNameFunctionName :: Typed.TypedName Kql.FunctionName +functionNameFunctionName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.FunctionName") + +-- | DSL constructor for hydra.ext.kusto.kql.IndexExpression +indexExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.IndexExpression +indexExpression expression index = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm index)}]})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.IndexExpression +indexExpressionExpression :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression +indexExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the index field of hydra.ext.kusto.kql.IndexExpression +indexExpressionIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm String +indexExpressionIndex x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.IndexExpression +indexExpressionIndexExpression :: Typed.TypedName Kql.IndexExpression +indexExpressionIndexExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.IndexExpression") + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.IndexExpression +indexExpressionWithExpression :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.IndexExpression +indexExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.projectionFieldName = (Model.Name "index")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the index field of hydra.ext.kusto.kql.IndexExpression +indexExpressionWithIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.IndexExpression +indexExpressionWithIndex original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "index"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.JoinCommand +joinCommand :: Typed.TypedTerm Kql.JoinKind -> Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.JoinCommand +joinCommand kind expression on = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Typed.unTypedTerm on)}]})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.JoinCommand +joinCommandExpression :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.TableName +joinCommandExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.JoinCommand +joinCommandJoinCommand :: Typed.TypedName Kql.JoinCommand +joinCommandJoinCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.JoinCommand") + +-- | DSL accessor for the kind field of hydra.ext.kusto.kql.JoinCommand +joinCommandKind :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.JoinKind +joinCommandKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the on field of hydra.ext.kusto.kql.JoinCommand +joinCommandOn :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Expression +joinCommandOn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.JoinCommand +joinCommandWithExpression :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.JoinCommand +joinCommandWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the kind field of hydra.ext.kusto.kql.JoinCommand +joinCommandWithKind :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.JoinKind -> Typed.TypedTerm Kql.JoinCommand +joinCommandWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "on")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the on field of hydra.ext.kusto.kql.JoinCommand +joinCommandWithOn :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.JoinCommand +joinCommandWithOn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "on"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the fullouter variant of hydra.ext.kusto.kql.JoinKind +joinKindFullouter :: Typed.TypedTerm Kql.JoinKind +joinKindFullouter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fullouter"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the inner variant of hydra.ext.kusto.kql.JoinKind +joinKindInner :: Typed.TypedTerm Kql.JoinKind +joinKindInner = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inner"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the innerunique variant of hydra.ext.kusto.kql.JoinKind +joinKindInnerunique :: Typed.TypedTerm Kql.JoinKind +joinKindInnerunique = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "innerunique"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.JoinKind +joinKindJoinKind :: Typed.TypedName Kql.JoinKind +joinKindJoinKind = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.JoinKind") + +-- | DSL injection for the leftanti variant of hydra.ext.kusto.kql.JoinKind +joinKindLeftanti :: Typed.TypedTerm Kql.JoinKind +joinKindLeftanti = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftanti"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftouter variant of hydra.ext.kusto.kql.JoinKind +joinKindLeftouter :: Typed.TypedTerm Kql.JoinKind +joinKindLeftouter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftouter"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the leftsemi variant of hydra.ext.kusto.kql.JoinKind +joinKindLeftsemi :: Typed.TypedTerm Kql.JoinKind +joinKindLeftsemi = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "leftsemi"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightanti variant of hydra.ext.kusto.kql.JoinKind +joinKindRightanti :: Typed.TypedTerm Kql.JoinKind +joinKindRightanti = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightanti"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightouter variant of hydra.ext.kusto.kql.JoinKind +joinKindRightouter :: Typed.TypedTerm Kql.JoinKind +joinKindRightouter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightouter"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rightsemi variant of hydra.ext.kusto.kql.JoinKind +joinKindRightsemi :: Typed.TypedTerm Kql.JoinKind +joinKindRightsemi = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rightsemi"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.kusto.kql.KeyValuePair +keyValuePair :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.KeyValuePair +keyValuePair key value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the key field of hydra.ext.kusto.kql.KeyValuePair +keyValuePairKey :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm String +keyValuePairKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.KeyValuePair +keyValuePairKeyValuePair :: Typed.TypedName Kql.KeyValuePair +keyValuePairKeyValuePair = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.KeyValuePair") + +-- | DSL accessor for the value field of hydra.ext.kusto.kql.KeyValuePair +keyValuePairValue :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm Kql.Expression +keyValuePairValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the key field of hydra.ext.kusto.kql.KeyValuePair +keyValuePairWithKey :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm String -> Typed.TypedTerm Kql.KeyValuePair +keyValuePairWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.kusto.kql.KeyValuePair +keyValuePairWithValue :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.KeyValuePair +keyValuePairWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.LetBinding +letBinding :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.LetBinding +letBinding name expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.LetBinding +letBindingExpression :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.Expression +letBindingExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.LetBinding +letBindingLetBinding :: Typed.TypedName Kql.LetBinding +letBindingLetBinding = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.LetBinding") + +-- | DSL accessor for the name field of hydra.ext.kusto.kql.LetBinding +letBindingName :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.ColumnName +letBindingName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.LetBinding +letBindingWithExpression :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.LetBinding +letBindingWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.kusto.kql.LetBinding +letBindingWithName :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.LetBinding +letBindingWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.LetExpression +letExpression :: Typed.TypedTerm [Kql.LetBinding] -> Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.LetExpression +letExpression bindings expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bindings"), + Model.fieldTerm = (Typed.unTypedTerm bindings)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the bindings field of hydra.ext.kusto.kql.LetExpression +letExpressionBindings :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm [Kql.LetBinding] +letExpressionBindings x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.projectionFieldName = (Model.Name "bindings")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.LetExpression +letExpressionExpression :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression +letExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.LetExpression +letExpressionLetExpression :: Typed.TypedName Kql.LetExpression +letExpressionLetExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.LetExpression") + +-- | DSL updater for the bindings field of hydra.ext.kusto.kql.LetExpression +letExpressionWithBindings :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm [Kql.LetBinding] -> Typed.TypedTerm Kql.LetExpression +letExpressionWithBindings original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bindings"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.LetExpression +letExpressionWithExpression :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.LetExpression +letExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bindings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"), + Model.projectionFieldName = (Model.Name "bindings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the boolean variant of hydra.ext.kusto.kql.Literal +literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Kql.Literal +literalBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the datetime variant of hydra.ext.kusto.kql.Literal +literalDatetime :: Typed.TypedTerm Kql.Datetime -> Typed.TypedTerm Kql.Literal +literalDatetime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "datetime"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the double variant of hydra.ext.kusto.kql.Literal +literalDouble :: Typed.TypedTerm Double -> Typed.TypedTerm Kql.Literal +literalDouble x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the duration variant of hydra.ext.kusto.kql.Literal +literalDuration :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.Literal +literalDuration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "duration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the int variant of hydra.ext.kusto.kql.Literal +literalInt :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Literal +literalInt x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.kusto.kql.Literal +literalLiteral :: Typed.TypedName Kql.Literal +literalLiteral = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Literal") + +-- | DSL injection for the long variant of hydra.ext.kusto.kql.Literal +literalLong :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Kql.Literal +literalLong x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.kusto.kql.Literal +literalString :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Literal +literalString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the ascending variant of hydra.ext.kusto.kql.Order +orderAscending :: Typed.TypedTerm Kql.Order +orderAscending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Order"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ascending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the descending variant of hydra.ext.kusto.kql.Order +orderDescending :: Typed.TypedTerm Kql.Order +orderDescending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Order"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.Order +orderOrder :: Typed.TypedName Kql.Order +orderOrder = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Order") + +-- | DSL constructor for hydra.ext.kusto.kql.Parameter +parameter :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Parameter +parameter key value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the key field of hydra.ext.kusto.kql.Parameter +parameterKey :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm String +parameterKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.Parameter +parameterParameter :: Typed.TypedName Kql.Parameter +parameterParameter = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Parameter") + +-- | DSL accessor for the value field of hydra.ext.kusto.kql.Parameter +parameterValue :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm Kql.Literal +parameterValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the key field of hydra.ext.kusto.kql.Parameter +parameterWithKey :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm String -> Typed.TypedTerm Kql.Parameter +parameterWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.kusto.kql.Parameter +parameterWithValue :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Parameter +parameterWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.ParseCommand +parseCommand :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm [Kql.KeyValuePair] -> Typed.TypedTerm Kql.ParseCommand +parseCommand column pairs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm column)}, + Model.Field { + Model.fieldName = (Model.Name "pairs"), + Model.fieldTerm = (Typed.unTypedTerm pairs)}]})) + +-- | DSL accessor for the column field of hydra.ext.kusto.kql.ParseCommand +parseCommandColumn :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.ColumnName +parseCommandColumn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pairs field of hydra.ext.kusto.kql.ParseCommand +parseCommandPairs :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm [Kql.KeyValuePair] +parseCommandPairs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.projectionFieldName = (Model.Name "pairs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.ParseCommand +parseCommandParseCommand :: Typed.TypedName Kql.ParseCommand +parseCommandParseCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ParseCommand") + +-- | DSL updater for the column field of hydra.ext.kusto.kql.ParseCommand +parseCommandWithColumn :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ParseCommand +parseCommandWithColumn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "pairs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.projectionFieldName = (Model.Name "pairs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pairs field of hydra.ext.kusto.kql.ParseCommand +parseCommandWithPairs :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm [Kql.KeyValuePair] -> Typed.TypedTerm Kql.ParseCommand +parseCommandWithPairs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pairs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.kusto.kql.PipelineExpression wrapper +pipelineExpression :: Typed.TypedTerm [Kql.TabularExpression] -> Typed.TypedTerm Kql.PipelineExpression +pipelineExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.PipelineExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.PipelineExpression +pipelineExpressionPipelineExpression :: Typed.TypedName Kql.PipelineExpression +pipelineExpressionPipelineExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PipelineExpression") + +-- | DSL constructor for hydra.ext.kusto.kql.PrintCommand +printCommand :: Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PrintCommand +printCommand column expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm column)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the column field of hydra.ext.kusto.kql.PrintCommand +printCommandColumn :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) +printCommandColumn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.PrintCommand +printCommandExpression :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Expression +printCommandExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.PrintCommand +printCommandPrintCommand :: Typed.TypedName Kql.PrintCommand +printCommandPrintCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PrintCommand") + +-- | DSL updater for the column field of hydra.ext.kusto.kql.PrintCommand +printCommandWithColumn :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.PrintCommand +printCommandWithColumn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.PrintCommand +printCommandWithExpression :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PrintCommand +printCommandWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.Projection +projection :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Projection +projection expression alias = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}]})) + +-- | DSL accessor for the alias field of hydra.ext.kusto.kql.Projection +projectionAlias :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm (Maybe Kql.ColumnName) +projectionAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.Projection +projectionExpression :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm Kql.Expression +projectionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.Projection +projectionProjection :: Typed.TypedName Kql.Projection +projectionProjection = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Projection") + +-- | DSL updater for the alias field of hydra.ext.kusto.kql.Projection +projectionWithAlias :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Projection +projectionWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.Projection +projectionWithExpression :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Projection +projectionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.PropertyExpression +propertyExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.PropertyExpression +propertyExpression expression property = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}, + Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm property)}]})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.PropertyExpression +propertyExpressionExpression :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression +propertyExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the property field of hydra.ext.kusto.kql.PropertyExpression +propertyExpressionProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm String +propertyExpressionProperty x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.projectionFieldName = (Model.Name "property")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.PropertyExpression +propertyExpressionPropertyExpression :: Typed.TypedName Kql.PropertyExpression +propertyExpressionPropertyExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PropertyExpression") + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.PropertyExpression +propertyExpressionWithExpression :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PropertyExpression +propertyExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.projectionFieldName = (Model.Name "property")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the property field of hydra.ext.kusto.kql.PropertyExpression +propertyExpressionWithProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.PropertyExpression +propertyExpressionWithProperty original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "property"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.kusto.kql.Query wrapper +query :: Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.Query +query x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.Query"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.Query +queryQuery :: Typed.TypedName Kql.Query +queryQuery = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Query") + +-- | DSL constructor for hydra.ext.kusto.kql.SearchCommand +searchCommand :: Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.SearchCommand +searchCommand datasets pattern = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "datasets"), + Model.fieldTerm = (Typed.unTypedTerm datasets)}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm pattern)}]})) + +-- | DSL accessor for the datasets field of hydra.ext.kusto.kql.SearchCommand +searchCommandDatasets :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm [Kql.TableName] +searchCommandDatasets x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.projectionFieldName = (Model.Name "datasets")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pattern field of hydra.ext.kusto.kql.SearchCommand +searchCommandPattern :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Expression +searchCommandPattern x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.SearchCommand +searchCommandSearchCommand :: Typed.TypedName Kql.SearchCommand +searchCommandSearchCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SearchCommand") + +-- | DSL updater for the datasets field of hydra.ext.kusto.kql.SearchCommand +searchCommandWithDatasets :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.SearchCommand +searchCommandWithDatasets original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "datasets"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.projectionFieldName = (Model.Name "pattern")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pattern field of hydra.ext.kusto.kql.SearchCommand +searchCommandWithPattern :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.SearchCommand +searchCommandWithPattern original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "datasets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"), + Model.projectionFieldName = (Model.Name "datasets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pattern"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.SortBy +sortBy :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm (Maybe Kql.Order) -> Typed.TypedTerm Kql.SortBy +sortBy column order = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm column)}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Typed.unTypedTerm order)}]})) + +-- | DSL accessor for the column field of hydra.ext.kusto.kql.SortBy +sortByColumn :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm Kql.ColumnName +sortByColumn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the order field of hydra.ext.kusto.kql.SortBy +sortByOrder :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm (Maybe Kql.Order) +sortByOrder x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.SortBy +sortBySortBy :: Typed.TypedName Kql.SortBy +sortBySortBy = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SortBy") + +-- | DSL updater for the column field of hydra.ext.kusto.kql.SortBy +sortByWithColumn :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.SortBy +sortByWithColumn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.projectionFieldName = (Model.Name "order")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the order field of hydra.ext.kusto.kql.SortBy +sortByWithOrder :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm (Maybe Kql.Order) -> Typed.TypedTerm Kql.SortBy +sortByWithOrder original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"), + Model.projectionFieldName = (Model.Name "column")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "order"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.kusto.kql.SummarizeCommand +summarizeCommand :: Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.SummarizeCommand +summarizeCommand columns by = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm columns)}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Typed.unTypedTerm by)}]})) + +-- | DSL accessor for the by field of hydra.ext.kusto.kql.SummarizeCommand +summarizeCommandBy :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnName] +summarizeCommandBy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.projectionFieldName = (Model.Name "by")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the columns field of hydra.ext.kusto.kql.SummarizeCommand +summarizeCommandColumns :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnAssignment] +summarizeCommandColumns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.SummarizeCommand +summarizeCommandSummarizeCommand :: Typed.TypedName Kql.SummarizeCommand +summarizeCommandSummarizeCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SummarizeCommand") + +-- | DSL updater for the by field of hydra.ext.kusto.kql.SummarizeCommand +summarizeCommandWithBy :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.SummarizeCommand +summarizeCommandWithBy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the columns field of hydra.ext.kusto.kql.SummarizeCommand +summarizeCommandWithColumns :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm Kql.SummarizeCommand +summarizeCommandWithColumns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "by"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"), + Model.projectionFieldName = (Model.Name "by")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.kusto.kql.TableName wrapper +tableName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.TableName +tableName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.TableName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.TableName +tableNameTableName :: Typed.TypedName Kql.TableName +tableNameTableName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TableName") + +-- | DSL injection for the command variant of hydra.ext.kusto.kql.TabularExpression +tabularExpressionCommand :: Typed.TypedTerm Kql.Command -> Typed.TypedTerm Kql.TabularExpression +tabularExpressionCommand x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "command"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the let variant of hydra.ext.kusto.kql.TabularExpression +tabularExpressionLet :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression +tabularExpressionLet x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "let"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pipeline variant of hydra.ext.kusto.kql.TabularExpression +tabularExpressionPipeline :: Typed.TypedTerm Kql.PipelineExpression -> Typed.TypedTerm Kql.TabularExpression +tabularExpressionPipeline x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pipeline"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the table variant of hydra.ext.kusto.kql.TabularExpression +tabularExpressionTable :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.TabularExpression +tabularExpressionTable x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "table"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.kusto.kql.TabularExpression +tabularExpressionTabularExpression :: Typed.TypedName Kql.TabularExpression +tabularExpressionTabularExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TabularExpression") + +-- | DSL constructor for hydra.ext.kusto.kql.TopCommand +topCommand :: Typed.TypedTerm Int -> Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.TopCommand +topCommand count sort = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Typed.unTypedTerm count)}, + Model.Field { + Model.fieldName = (Model.Name "sort"), + Model.fieldTerm = (Typed.unTypedTerm sort)}]})) + +-- | DSL accessor for the count field of hydra.ext.kusto.kql.TopCommand +topCommandCount :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Int +topCommandCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.projectionFieldName = (Model.Name "count")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the sort field of hydra.ext.kusto.kql.TopCommand +topCommandSort :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm [Kql.SortBy] +topCommandSort x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.projectionFieldName = (Model.Name "sort")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.TopCommand +topCommandTopCommand :: Typed.TypedName Kql.TopCommand +topCommandTopCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TopCommand") + +-- | DSL updater for the count field of hydra.ext.kusto.kql.TopCommand +topCommandWithCount :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Int -> Typed.TypedTerm Kql.TopCommand +topCommandWithCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "sort"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.projectionFieldName = (Model.Name "sort")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the sort field of hydra.ext.kusto.kql.TopCommand +topCommandWithSort :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.TopCommand +topCommandWithSort original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"), + Model.projectionFieldName = (Model.Name "count")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sort"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.ColumnName +unColumnName :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm String +unColumnName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.ColumnName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.Datetime +unDatetime :: Typed.TypedTerm Kql.Datetime -> Typed.TypedTerm String +unDatetime x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.Datetime")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.FunctionName +unFunctionName :: Typed.TypedTerm Kql.FunctionName -> Typed.TypedTerm String +unFunctionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.FunctionName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.PipelineExpression +unPipelineExpression :: Typed.TypedTerm Kql.PipelineExpression -> Typed.TypedTerm [Kql.TabularExpression] +unPipelineExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.PipelineExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.Query +unQuery :: Typed.TypedTerm Kql.Query -> Typed.TypedTerm Kql.TabularExpression +unQuery x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.Query")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.kusto.kql.TableName +unTableName :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm String +unTableName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.TableName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.kusto.kql.UnaryExpression +unaryExpression :: Typed.TypedTerm Kql.UnaryOperator -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.UnaryExpression +unaryExpression operator expression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm operator)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm expression)}]})) + +-- | DSL accessor for the expression field of hydra.ext.kusto.kql.UnaryExpression +unaryExpressionExpression :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression +unaryExpressionExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the operator field of hydra.ext.kusto.kql.UnaryExpression +unaryExpressionOperator :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.UnaryOperator +unaryExpressionOperator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.UnaryExpression +unaryExpressionUnaryExpression :: Typed.TypedName Kql.UnaryExpression +unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnaryExpression") + +-- | DSL updater for the expression field of hydra.ext.kusto.kql.UnaryExpression +unaryExpressionWithExpression :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.UnaryExpression +unaryExpressionWithExpression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.projectionFieldName = (Model.Name "operator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the operator field of hydra.ext.kusto.kql.UnaryExpression +unaryExpressionWithOperator :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.UnaryOperator -> Typed.TypedTerm Kql.UnaryExpression +unaryExpressionWithOperator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "operator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "expression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"), + Model.projectionFieldName = (Model.Name "expression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the not variant of hydra.ext.kusto.kql.UnaryOperator +unaryOperatorNot :: Typed.TypedTerm Kql.UnaryOperator +unaryOperatorNot = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryOperator"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "not"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.UnaryOperator +unaryOperatorUnaryOperator :: Typed.TypedName Kql.UnaryOperator +unaryOperatorUnaryOperator = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnaryOperator") + +-- | DSL constructor for hydra.ext.kusto.kql.UnionCommand +unionCommand :: Typed.TypedTerm [Kql.Parameter] -> Typed.TypedTerm (Maybe Kql.UnionKind) -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.UnionCommand +unionCommand parameters kind withSource isFuzzy tables = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm parameters)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Typed.unTypedTerm withSource)}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Typed.unTypedTerm isFuzzy)}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Typed.unTypedTerm tables)}]})) + +-- | DSL accessor for the isFuzzy field of hydra.ext.kusto.kql.UnionCommand +unionCommandIsFuzzy :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Bool) +unionCommandIsFuzzy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "isFuzzy")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the kind field of hydra.ext.kusto.kql.UnionCommand +unionCommandKind :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.UnionKind) +unionCommandKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the parameters field of hydra.ext.kusto.kql.UnionCommand +unionCommandParameters :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.Parameter] +unionCommandParameters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the tables field of hydra.ext.kusto.kql.UnionCommand +unionCommandTables :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.TableName] +unionCommandTables x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "tables")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.kusto.kql.UnionCommand +unionCommandUnionCommand :: Typed.TypedName Kql.UnionCommand +unionCommandUnionCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnionCommand") + +-- | DSL updater for the isFuzzy field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithIsFuzzy :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Kql.UnionCommand +unionCommandWithIsFuzzy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "withSource")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "tables")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the kind field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithKind :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.UnionKind) -> Typed.TypedTerm Kql.UnionCommand +unionCommandWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "withSource")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "isFuzzy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "tables")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the parameters field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithParameters :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.Parameter] -> Typed.TypedTerm Kql.UnionCommand +unionCommandWithParameters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "withSource")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "isFuzzy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "tables")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the withSource field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithSource :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) +unionCommandWithSource x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "withSource")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the tables field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithTables :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.UnionCommand +unionCommandWithTables original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "withSource")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "isFuzzy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the withSource field of hydra.ext.kusto.kql.UnionCommand +unionCommandWithWithSource :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.UnionCommand +unionCommandWithWithSource original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "parameters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "parameters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withSource"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isFuzzy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "isFuzzy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "tables"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"), + Model.projectionFieldName = (Model.Name "tables")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the inner variant of hydra.ext.kusto.kql.UnionKind +unionKindInner :: Typed.TypedTerm Kql.UnionKind +unionKindInner = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inner"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the outer variant of hydra.ext.kusto.kql.UnionKind +unionKindOuter :: Typed.TypedTerm Kql.UnionKind +unionKindOuter = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "outer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.kusto.kql.UnionKind +unionKindUnionKind :: Typed.TypedName Kql.UnionKind +unionKindUnionKind = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnionKind") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Osv/Schema.hs b/src/main/haskell/Hydra/Ext/Dsl/Osv/Schema.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Osv/Schema.hs @@ -0,0 +1,2239 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.osv.schema + +module Hydra.Ext.Dsl.Osv.Schema where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Osv.Schema as Schema +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.osv.schema.Credited +credited :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe [Schema.Url]) -> Typed.TypedTerm Schema.Credited +credited name contact = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "contact"), + Model.fieldTerm = (Typed.unTypedTerm contact)}]})) + +-- | DSL accessor for the contact field of hydra.ext.osv.schema.Credited +creditedContact :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm (Maybe [Schema.Url]) +creditedContact x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.projectionFieldName = (Model.Name "contact")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Credited +creditedCredited :: Typed.TypedName Schema.Credited +creditedCredited = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Credited") + +-- | DSL accessor for the name field of hydra.ext.osv.schema.Credited +creditedName :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm String +creditedName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the contact field of hydra.ext.osv.schema.Credited +creditedWithContact :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm (Maybe [Schema.Url]) -> Typed.TypedTerm Schema.Credited +creditedWithContact original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "contact"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.osv.schema.Credited +creditedWithName :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Credited +creditedWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "contact"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Credited"), + Model.projectionFieldName = (Model.Name "contact")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.osv.schema.Ecosystem wrapper +ecosystem :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Ecosystem +ecosystem x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Ecosystem"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Ecosystem +ecosystemEcosystem :: Typed.TypedName Schema.Ecosystem +ecosystemEcosystem = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Ecosystem") + +-- | DSL constructor for hydra.ext.osv.schema.Entry +entry :: Typed.TypedTerm (Maybe Schema.OsvVersion) -> Typed.TypedTerm Schema.Id -> Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Schema.Markdown) -> Typed.TypedTerm (Maybe [Schema.Severity]) -> Typed.TypedTerm (Maybe [Schema.PackageVersions]) -> Typed.TypedTerm (Maybe [Schema.Reference]) -> Typed.TypedTerm (Maybe [Schema.Credited]) -> Typed.TypedTerm Schema.Entry +entry schemaVersion id modified published withdrawn aliases related summary details severity affected references credits = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Typed.unTypedTerm schemaVersion)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm id)}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Typed.unTypedTerm modified)}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Typed.unTypedTerm published)}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Typed.unTypedTerm withdrawn)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm aliases)}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Typed.unTypedTerm related)}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Typed.unTypedTerm summary)}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Typed.unTypedTerm details)}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm severity)}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Typed.unTypedTerm affected)}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Typed.unTypedTerm references)}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Typed.unTypedTerm credits)}]})) + +-- | DSL accessor for the affected field of hydra.ext.osv.schema.Entry +entryAffected :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.PackageVersions]) +entryAffected x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the aliases field of hydra.ext.osv.schema.Entry +entryAliases :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) +entryAliases x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the credits field of hydra.ext.osv.schema.Entry +entryCredits :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Credited]) +entryCredits x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the details field of hydra.ext.osv.schema.Entry +entryDetails :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Markdown) +entryDetails x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Entry +entryEntry :: Typed.TypedName Schema.Entry +entryEntry = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Entry") + +-- | DSL accessor for the id field of hydra.ext.osv.schema.Entry +entryId :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Id +entryId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the modified field of hydra.ext.osv.schema.Entry +entryModified :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Timestamp +entryModified x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the published field of hydra.ext.osv.schema.Entry +entryPublished :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) +entryPublished x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the references field of hydra.ext.osv.schema.Entry +entryReferences :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Reference]) +entryReferences x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the related field of hydra.ext.osv.schema.Entry +entryRelated :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) +entryRelated x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schemaVersion field of hydra.ext.osv.schema.Entry +entrySchemaVersion :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.OsvVersion) +entrySchemaVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the severity field of hydra.ext.osv.schema.Entry +entrySeverity :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Severity]) +entrySeverity x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the summary field of hydra.ext.osv.schema.Entry +entrySummary :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe String) +entrySummary x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the affected field of hydra.ext.osv.schema.Entry +entryWithAffected :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.PackageVersions]) -> Typed.TypedTerm Schema.Entry +entryWithAffected original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the aliases field of hydra.ext.osv.schema.Entry +entryWithAliases :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm Schema.Entry +entryWithAliases original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the credits field of hydra.ext.osv.schema.Entry +entryWithCredits :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Credited]) -> Typed.TypedTerm Schema.Entry +entryWithCredits original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the details field of hydra.ext.osv.schema.Entry +entryWithDetails :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Markdown) -> Typed.TypedTerm Schema.Entry +entryWithDetails original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the id field of hydra.ext.osv.schema.Entry +entryWithId :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Id -> Typed.TypedTerm Schema.Entry +entryWithId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the modified field of hydra.ext.osv.schema.Entry +entryWithModified :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm Schema.Entry +entryWithModified original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the published field of hydra.ext.osv.schema.Entry +entryWithPublished :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm Schema.Entry +entryWithPublished original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the references field of hydra.ext.osv.schema.Entry +entryWithReferences :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Reference]) -> Typed.TypedTerm Schema.Entry +entryWithReferences original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the related field of hydra.ext.osv.schema.Entry +entryWithRelated :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm Schema.Entry +entryWithRelated original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schemaVersion field of hydra.ext.osv.schema.Entry +entryWithSchemaVersion :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.OsvVersion) -> Typed.TypedTerm Schema.Entry +entryWithSchemaVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the severity field of hydra.ext.osv.schema.Entry +entryWithSeverity :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Severity]) -> Typed.TypedTerm Schema.Entry +entryWithSeverity original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the summary field of hydra.ext.osv.schema.Entry +entryWithSummary :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Entry +entryWithSummary original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the withdrawn field of hydra.ext.osv.schema.Entry +entryWithWithdrawn :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm Schema.Entry +entryWithWithdrawn original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "schemaVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "schemaVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "id"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "id")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "modified"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "modified")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "published")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "withdrawn"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aliases"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "aliases")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "related"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "related")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "summary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "summary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "details"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "details")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "affected"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "affected")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "references"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "references")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "credits"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "credits")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL accessor for the withdrawn field of hydra.ext.osv.schema.Entry +entryWithdrawn :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) +entryWithdrawn x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"), + Model.projectionFieldName = (Model.Name "withdrawn")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Event +eventEvent :: Typed.TypedName Schema.Event +eventEvent = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Event") + +-- | DSL injection for the fixed variant of hydra.ext.osv.schema.Event +eventFixed :: Typed.TypedTerm Schema.Version -> Typed.TypedTerm Schema.Event +eventFixed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the introduced variant of hydra.ext.osv.schema.Event +eventIntroduced :: Typed.TypedTerm Schema.VersionOrZero -> Typed.TypedTerm Schema.Event +eventIntroduced x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "introduced"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the lastAffected variant of hydra.ext.osv.schema.Event +eventLastAffected :: Typed.TypedTerm Schema.Version -> Typed.TypedTerm Schema.Event +eventLastAffected x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lastAffected"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the limit variant of hydra.ext.osv.schema.Event +eventLimit :: Typed.TypedTerm Schema.VersionOrStar -> Typed.TypedTerm Schema.Event +eventLimit x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "limit"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.osv.schema.Id wrapper +id :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Id +id x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Id"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Id +idId :: Typed.TypedName Schema.Id +idId = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Id") + +-- | DSL constructor for the hydra.ext.osv.schema.Markdown wrapper +markdown :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Markdown +markdown x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Markdown"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Markdown +markdownMarkdown :: Typed.TypedName Schema.Markdown +markdownMarkdown = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Markdown") + +-- | DSL constructor for the hydra.ext.osv.schema.OsvVersion wrapper +osvVersion :: Typed.TypedTerm String -> Typed.TypedTerm Schema.OsvVersion +osvVersion x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.OsvVersion"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.OsvVersion +osvVersionOsvVersion :: Typed.TypedName Schema.OsvVersion +osvVersionOsvVersion = Typed.TypedName (Model.Name "hydra.ext.osv.schema.OsvVersion") + +-- | DSL constructor for hydra.ext.osv.schema.Package +package :: Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.Package +package ecosystem name purl = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ecosystem"), + Model.fieldTerm = (Typed.unTypedTerm ecosystem)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "purl"), + Model.fieldTerm = (Typed.unTypedTerm purl)}]})) + +-- | DSL accessor for the ecosystem field of hydra.ext.osv.schema.Package +packageEcosystem :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm Schema.Ecosystem +packageEcosystem x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "ecosystem")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.osv.schema.Package +packageName :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm String +packageName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Package +packagePackage :: Typed.TypedName Schema.Package +packagePackage = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Package") + +-- | DSL accessor for the purl field of hydra.ext.osv.schema.Package +packagePurl :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe Schema.Url) +packagePurl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "purl")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.osv.schema.PackageVersions +packageVersions :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe [Schema.VersionRange]) -> Typed.TypedTerm (Maybe [Schema.Version]) -> Typed.TypedTerm Schema.PackageVersions +packageVersions package ranges versions = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm package)}, + Model.Field { + Model.fieldName = (Model.Name "ranges"), + Model.fieldTerm = (Typed.unTypedTerm ranges)}, + Model.Field { + Model.fieldName = (Model.Name "versions"), + Model.fieldTerm = (Typed.unTypedTerm versions)}]})) + +-- | DSL accessor for the package field of hydra.ext.osv.schema.PackageVersions +packageVersionsPackage :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm Schema.Package +packageVersionsPackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.PackageVersions +packageVersionsPackageVersions :: Typed.TypedName Schema.PackageVersions +packageVersionsPackageVersions = Typed.TypedName (Model.Name "hydra.ext.osv.schema.PackageVersions") + +-- | DSL accessor for the ranges field of hydra.ext.osv.schema.PackageVersions +packageVersionsRanges :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.VersionRange]) +packageVersionsRanges x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "ranges")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the versions field of hydra.ext.osv.schema.PackageVersions +packageVersionsVersions :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.Version]) +packageVersionsVersions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "versions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the package field of hydra.ext.osv.schema.PackageVersions +packageVersionsWithPackage :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm Schema.Package -> Typed.TypedTerm Schema.PackageVersions +packageVersionsWithPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ranges"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "ranges")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "versions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "versions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ranges field of hydra.ext.osv.schema.PackageVersions +packageVersionsWithRanges :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.VersionRange]) -> Typed.TypedTerm Schema.PackageVersions +packageVersionsWithRanges original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ranges"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "versions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "versions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the versions field of hydra.ext.osv.schema.PackageVersions +packageVersionsWithVersions :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.Version]) -> Typed.TypedTerm Schema.PackageVersions +packageVersionsWithVersions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ranges"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"), + Model.projectionFieldName = (Model.Name "ranges")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "versions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the ecosystem field of hydra.ext.osv.schema.Package +packageWithEcosystem :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm Schema.Package +packageWithEcosystem original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ecosystem"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "purl"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "purl")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.osv.schema.Package +packageWithName :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Package +packageWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ecosystem"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "ecosystem")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "purl"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "purl")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the purl field of hydra.ext.osv.schema.Package +packageWithPurl :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.Package +packageWithPurl original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "ecosystem"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "ecosystem")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "purl"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.osv.schema.Reference +reference :: Typed.TypedTerm Schema.ReferenceType -> Typed.TypedTerm Schema.Url -> Typed.TypedTerm Schema.Reference +reference type_ url = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Typed.unTypedTerm url)}]})) + +-- | DSL name token for hydra.ext.osv.schema.Reference +referenceReference :: Typed.TypedName Schema.Reference +referenceReference = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Reference") + +-- | DSL accessor for the type field of hydra.ext.osv.schema.Reference +referenceType :: Typed.TypedTerm Schema.Reference -> Typed.TypedTerm Schema.ReferenceType +referenceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.osv.schema.ReferenceType wrapper +referenceType2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.ReferenceType +referenceType2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.ReferenceType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.ReferenceType +referenceTypeReferenceType :: Typed.TypedName Schema.ReferenceType +referenceTypeReferenceType = Typed.TypedName (Model.Name "hydra.ext.osv.schema.ReferenceType") + +-- | DSL accessor for the url field of hydra.ext.osv.schema.Reference +referenceUrl :: Typed.TypedTerm Schema.Reference -> Typed.TypedTerm Schema.Url +referenceUrl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the type field of hydra.ext.osv.schema.Reference +referenceWithType :: Typed.TypedTerm Schema.Reference -> Typed.TypedTerm Schema.ReferenceType -> Typed.TypedTerm Schema.Reference +referenceWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the url field of hydra.ext.osv.schema.Reference +referenceWithUrl :: Typed.TypedTerm Schema.Reference -> Typed.TypedTerm Schema.Url -> Typed.TypedTerm Schema.Reference +referenceWithUrl original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Reference"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.osv.schema.Severity +severity :: Typed.TypedTerm Schema.SeverityType -> Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm Schema.Severity +severity type_ score = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "score"), + Model.fieldTerm = (Typed.unTypedTerm score)}]})) + +-- | DSL accessor for the score field of hydra.ext.osv.schema.Severity +severityScore :: Typed.TypedTerm Schema.Severity -> Typed.TypedTerm Schema.SeverityScore +severityScore x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.projectionFieldName = (Model.Name "score")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.osv.schema.SeverityScore wrapper +severityScore2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.SeverityScore +severityScore2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.SeverityScore"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.SeverityScore +severityScoreSeverityScore :: Typed.TypedName Schema.SeverityScore +severityScoreSeverityScore = Typed.TypedName (Model.Name "hydra.ext.osv.schema.SeverityScore") + +-- | DSL name token for hydra.ext.osv.schema.Severity +severitySeverity :: Typed.TypedName Schema.Severity +severitySeverity = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Severity") + +-- | DSL accessor for the type field of hydra.ext.osv.schema.Severity +severityType :: Typed.TypedTerm Schema.Severity -> Typed.TypedTerm Schema.SeverityType +severityType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.osv.schema.SeverityType wrapper +severityType2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.SeverityType +severityType2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.SeverityType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.SeverityType +severityTypeSeverityType :: Typed.TypedName Schema.SeverityType +severityTypeSeverityType = Typed.TypedName (Model.Name "hydra.ext.osv.schema.SeverityType") + +-- | DSL updater for the score field of hydra.ext.osv.schema.Severity +severityWithScore :: Typed.TypedTerm Schema.Severity -> Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm Schema.Severity +severityWithScore original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "score"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.osv.schema.Severity +severityWithType :: Typed.TypedTerm Schema.Severity -> Typed.TypedTerm Schema.SeverityType -> Typed.TypedTerm Schema.Severity +severityWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "score"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Severity"), + Model.projectionFieldName = (Model.Name "score")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.osv.schema.Timestamp wrapper +timestamp :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Timestamp +timestamp x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Timestamp"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Timestamp +timestampTimestamp :: Typed.TypedName Schema.Timestamp +timestampTimestamp = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Timestamp") + +-- | DSL accessor for the body of hydra.ext.osv.schema.Ecosystem +unEcosystem :: Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm String +unEcosystem x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Ecosystem")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.Id +unId :: Typed.TypedTerm Schema.Id -> Typed.TypedTerm String +unId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Id")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.Markdown +unMarkdown :: Typed.TypedTerm Schema.Markdown -> Typed.TypedTerm String +unMarkdown x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Markdown")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.OsvVersion +unOsvVersion :: Typed.TypedTerm Schema.OsvVersion -> Typed.TypedTerm String +unOsvVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.OsvVersion")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.ReferenceType +unReferenceType :: Typed.TypedTerm Schema.ReferenceType -> Typed.TypedTerm String +unReferenceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.ReferenceType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.SeverityScore +unSeverityScore :: Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm String +unSeverityScore x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.SeverityScore")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.SeverityType +unSeverityType :: Typed.TypedTerm Schema.SeverityType -> Typed.TypedTerm String +unSeverityType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.SeverityType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.Timestamp +unTimestamp :: Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm String +unTimestamp x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Timestamp")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.Url +unUrl :: Typed.TypedTerm Schema.Url -> Typed.TypedTerm String +unUrl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Url")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.Version +unVersion :: Typed.TypedTerm Schema.Version -> Typed.TypedTerm String +unVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Version")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.VersionOrStar +unVersionOrStar :: Typed.TypedTerm Schema.VersionOrStar -> Typed.TypedTerm String +unVersionOrStar x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionOrStar")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.VersionOrZero +unVersionOrZero :: Typed.TypedTerm Schema.VersionOrZero -> Typed.TypedTerm String +unVersionOrZero x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionOrZero")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.osv.schema.VersionType +unVersionType :: Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm String +unVersionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.osv.schema.Url wrapper +url :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Url +url x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Url"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.Url +urlUrl :: Typed.TypedName Schema.Url +urlUrl = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Url") + +-- | DSL constructor for the hydra.ext.osv.schema.Version wrapper +version :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Version +version x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Version"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.osv.schema.VersionOrStar wrapper +versionOrStar :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionOrStar +versionOrStar x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionOrStar"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.VersionOrStar +versionOrStarVersionOrStar :: Typed.TypedName Schema.VersionOrStar +versionOrStarVersionOrStar = Typed.TypedName (Model.Name "hydra.ext.osv.schema.VersionOrStar") + +-- | DSL constructor for the hydra.ext.osv.schema.VersionOrZero wrapper +versionOrZero :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionOrZero +versionOrZero x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionOrZero"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.VersionOrZero +versionOrZeroVersionOrZero :: Typed.TypedName Schema.VersionOrZero +versionOrZeroVersionOrZero = Typed.TypedName (Model.Name "hydra.ext.osv.schema.VersionOrZero") + +-- | DSL constructor for hydra.ext.osv.schema.VersionRange +versionRange :: Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm [Schema.Event] -> Typed.TypedTerm Schema.VersionRange +versionRange type_ repo events = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "repo"), + Model.fieldTerm = (Typed.unTypedTerm repo)}, + Model.Field { + Model.fieldName = (Model.Name "events"), + Model.fieldTerm = (Typed.unTypedTerm events)}]})) + +-- | DSL accessor for the events field of hydra.ext.osv.schema.VersionRange +versionRangeEvents :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm [Schema.Event] +versionRangeEvents x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "events")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the repo field of hydra.ext.osv.schema.VersionRange +versionRangeRepo :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm (Maybe Schema.Url) +versionRangeRepo x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "repo")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.osv.schema.VersionRange +versionRangeType :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm Schema.VersionType +versionRangeType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.VersionRange +versionRangeVersionRange :: Typed.TypedName Schema.VersionRange +versionRangeVersionRange = Typed.TypedName (Model.Name "hydra.ext.osv.schema.VersionRange") + +-- | DSL updater for the events field of hydra.ext.osv.schema.VersionRange +versionRangeWithEvents :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm [Schema.Event] -> Typed.TypedTerm Schema.VersionRange +versionRangeWithEvents original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repo"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "repo")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "events"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the repo field of hydra.ext.osv.schema.VersionRange +versionRangeWithRepo :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.VersionRange +versionRangeWithRepo original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repo"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "events"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "events")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.osv.schema.VersionRange +versionRangeWithType :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm Schema.VersionRange +versionRangeWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "repo"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "repo")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "events"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"), + Model.projectionFieldName = (Model.Name "events")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.osv.schema.VersionType wrapper +versionType :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionType +versionType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.osv.schema.VersionType +versionTypeVersionType :: Typed.TypedName Schema.VersionType +versionTypeVersionType = Typed.TypedName (Model.Name "hydra.ext.osv.schema.VersionType") + +-- | DSL name token for hydra.ext.osv.schema.Version +versionVersion :: Typed.TypedName Schema.Version +versionVersion = Typed.TypedName (Model.Name "hydra.ext.osv.schema.Version") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Parquet/Format.hs b/src/main/haskell/Hydra/Ext/Dsl/Parquet/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Parquet/Format.hs @@ -0,0 +1,7789 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.parquet.format + +module Hydra.Ext.Dsl.Parquet.Format where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Parquet.Format as Format +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.ByteString as B +import qualified Data.Int as I + +-- | DSL constructor for hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1 :: Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmCtrV1 +aesGcmCtrV1 aadPrefix aadFileUnique supplyAadPrefix = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm aadPrefix)}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Typed.unTypedTerm aadFileUnique)}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm supplyAadPrefix)}]})) + +-- | DSL accessor for the aadFileUnique field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1AadFileUnique :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) +aesGcmCtrV1AadFileUnique x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the aadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1AadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) +aesGcmCtrV1AadPrefix x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1AesGcmCtrV1 :: Typed.TypedName Format.AesGcmCtrV1 +aesGcmCtrV1AesGcmCtrV1 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1") + +-- | DSL accessor for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1SupplyAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe Bool) +aesGcmCtrV1SupplyAadPrefix x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the aadFileUnique field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1WithAadFileUnique :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmCtrV1 +aesGcmCtrV1WithAadFileUnique original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the aadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1WithAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmCtrV1 +aesGcmCtrV1WithAadPrefix original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1 +aesGcmCtrV1WithSupplyAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmCtrV1 +aesGcmCtrV1WithSupplyAadPrefix original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.AesGcmV1 +aesGcmV1 :: Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmV1 +aesGcmV1 aadPrefix aadFileUnique supplyAadPrefix = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm aadPrefix)}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Typed.unTypedTerm aadFileUnique)}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm supplyAadPrefix)}]})) + +-- | DSL accessor for the aadFileUnique field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1AadFileUnique :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) +aesGcmV1AadFileUnique x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the aadPrefix field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1AadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) +aesGcmV1AadPrefix x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.AesGcmV1 +aesGcmV1AesGcmV1 :: Typed.TypedName Format.AesGcmV1 +aesGcmV1AesGcmV1 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.AesGcmV1") + +-- | DSL accessor for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1SupplyAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe Bool) +aesGcmV1SupplyAadPrefix x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the aadFileUnique field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1WithAadFileUnique :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmV1 +aesGcmV1WithAadFileUnique original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the aadPrefix field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1WithAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmV1 +aesGcmV1WithAadPrefix original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "supplyAadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmV1 +aesGcmV1WithSupplyAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmV1 +aesGcmV1WithSupplyAadPrefix original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "aadPrefix"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadPrefix")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "aadFileUnique"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"), + Model.projectionFieldName = (Model.Name "aadFileUnique")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "supplyAadPrefix"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the block variant of hydra.ext.parquet.format.BloomFilterAlgorithm +bloomFilterAlgorithmBlock :: Typed.TypedTerm Format.BloomFilterAlgorithm +bloomFilterAlgorithmBlock = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterAlgorithm"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "block"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.BloomFilterAlgorithm +bloomFilterAlgorithmBloomFilterAlgorithm :: Typed.TypedName Format.BloomFilterAlgorithm +bloomFilterAlgorithmBloomFilterAlgorithm = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterAlgorithm") + +-- | DSL name token for hydra.ext.parquet.format.BloomFilterCompression +bloomFilterCompressionBloomFilterCompression :: Typed.TypedName Format.BloomFilterCompression +bloomFilterCompressionBloomFilterCompression = + Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterCompression") + +-- | DSL injection for the uncompressed variant of hydra.ext.parquet.format.BloomFilterCompression +bloomFilterCompressionUncompressed :: Typed.TypedTerm Format.BloomFilterCompression +bloomFilterCompressionUncompressed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterCompression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uncompressed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.BloomFilterHash +bloomFilterHashBloomFilterHash :: Typed.TypedName Format.BloomFilterHash +bloomFilterHashBloomFilterHash = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterHash") + +-- | DSL injection for the xxhash variant of hydra.ext.parquet.format.BloomFilterHash +bloomFilterHashXxhash :: Typed.TypedTerm Format.BloomFilterHash +bloomFilterHashXxhash = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHash"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "xxhash"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.BloomFilterAlgorithm -> Typed.TypedTerm Format.BloomFilterHash -> Typed.TypedTerm Format.BloomFilterCompression -> Typed.TypedTerm Format.BloomFilterHeader +bloomFilterHeader numBytes algorithm hash compression = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numBytes"), + Model.fieldTerm = (Typed.unTypedTerm numBytes)}, + Model.Field { + Model.fieldName = (Model.Name "algorithm"), + Model.fieldTerm = (Typed.unTypedTerm algorithm)}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Typed.unTypedTerm hash)}, + Model.Field { + Model.fieldName = (Model.Name "compression"), + Model.fieldTerm = (Typed.unTypedTerm compression)}]})) + +-- | DSL accessor for the algorithm field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderAlgorithm :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterAlgorithm +bloomFilterHeaderAlgorithm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "algorithm")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderBloomFilterHeader :: Typed.TypedName Format.BloomFilterHeader +bloomFilterHeaderBloomFilterHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterHeader") + +-- | DSL accessor for the compression field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderCompression :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterCompression +bloomFilterHeaderCompression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "compression")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hash field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderHash :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterHash +bloomFilterHeaderHash x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numBytes field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderNumBytes :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Int +bloomFilterHeaderNumBytes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "numBytes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the algorithm field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderWithAlgorithm :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterAlgorithm -> Typed.TypedTerm Format.BloomFilterHeader +bloomFilterHeaderWithAlgorithm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numBytes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "numBytes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "algorithm"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "compression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the compression field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderWithCompression :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterCompression -> Typed.TypedTerm Format.BloomFilterHeader +bloomFilterHeaderWithCompression original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numBytes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "numBytes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "algorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "algorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compression"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the hash field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderWithHash :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterHash -> Typed.TypedTerm Format.BloomFilterHeader +bloomFilterHeaderWithHash original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numBytes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "numBytes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "algorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "algorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "compression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "compression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numBytes field of hydra.ext.parquet.format.BloomFilterHeader +bloomFilterHeaderWithNumBytes :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.BloomFilterHeader +bloomFilterHeaderWithNumBytes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numBytes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "algorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "algorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compression"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"), + Model.projectionFieldName = (Model.Name "compression")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the ascending variant of hydra.ext.parquet.format.BoundaryOrder +boundaryOrderAscending :: Typed.TypedTerm Format.BoundaryOrder +boundaryOrderAscending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "ascending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.BoundaryOrder +boundaryOrderBoundaryOrder :: Typed.TypedName Format.BoundaryOrder +boundaryOrderBoundaryOrder = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BoundaryOrder") + +-- | DSL injection for the descending variant of hydra.ext.parquet.format.BoundaryOrder +boundaryOrderDescending :: Typed.TypedTerm Format.BoundaryOrder +boundaryOrderDescending = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the unordered variant of hydra.ext.parquet.format.BoundaryOrder +boundaryOrderUnordered :: Typed.TypedTerm Format.BoundaryOrder +boundaryOrderUnordered = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unordered"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.parquet.format.ColumnChunk +columnChunk :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe Format.ColumnMetaData) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.ColumnChunk +columnChunk filePath fileOffset metaData offsetIndexOffset offsetIndexLength columnIndexOffset columnIndexLength cryptoMetadata encryptedColumnMetadata = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Typed.unTypedTerm filePath)}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Typed.unTypedTerm fileOffset)}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Typed.unTypedTerm metaData)}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Typed.unTypedTerm offsetIndexOffset)}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Typed.unTypedTerm offsetIndexLength)}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Typed.unTypedTerm columnIndexOffset)}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Typed.unTypedTerm columnIndexLength)}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Typed.unTypedTerm cryptoMetadata)}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Typed.unTypedTerm encryptedColumnMetadata)}]})) + +-- | DSL name token for hydra.ext.parquet.format.ColumnChunk +columnChunkColumnChunk :: Typed.TypedName Format.ColumnChunk +columnChunkColumnChunk = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnChunk") + +-- | DSL accessor for the columnIndexLength field of hydra.ext.parquet.format.ColumnChunk +columnChunkColumnIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) +columnChunkColumnIndexLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the columnIndexOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkColumnIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) +columnChunkColumnIndexOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the cryptoMetadata field of hydra.ext.parquet.format.ColumnChunk +columnChunkCryptoMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData) +columnChunkCryptoMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encryptedColumnMetadata field of hydra.ext.parquet.format.ColumnChunk +columnChunkEncryptedColumnMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe B.ByteString) +columnChunkEncryptedColumnMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the fileOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkFileOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm I.Int64 +columnChunkFileOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the filePath field of hydra.ext.parquet.format.ColumnChunk +columnChunkFilePath :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe String) +columnChunkFilePath x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the metaData field of hydra.ext.parquet.format.ColumnChunk +columnChunkMetaData :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnMetaData) +columnChunkMetaData x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the offsetIndexLength field of hydra.ext.parquet.format.ColumnChunk +columnChunkOffsetIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) +columnChunkOffsetIndexLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the offsetIndexOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkOffsetIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) +columnChunkOffsetIndexOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the columnIndexLength field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithColumnIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithColumnIndexLength original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the columnIndexOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithColumnIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithColumnIndexOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the cryptoMetadata field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithCryptoMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithCryptoMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encryptedColumnMetadata field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithEncryptedColumnMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithEncryptedColumnMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the fileOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithFileOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithFileOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the filePath field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithFilePath :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithFilePath original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the metaData field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithMetaData :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnMetaData) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithMetaData original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the offsetIndexLength field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithOffsetIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithOffsetIndexLength original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the offsetIndexOffset field of hydra.ext.parquet.format.ColumnChunk +columnChunkWithOffsetIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnChunk +columnChunkWithOffsetIndexOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "filePath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "filePath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metaData"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "metaData")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "offsetIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "offsetIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnIndexLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "columnIndexLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "cryptoMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "cryptoMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptedColumnMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"), + Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.parquet.format.ColumnCryptoMetaData +columnCryptoMetaDataColumnCryptoMetaData :: Typed.TypedName Format.ColumnCryptoMetaData +columnCryptoMetaDataColumnCryptoMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData") + +-- | DSL injection for the encryptionWithColumnKey variant of hydra.ext.parquet.format.ColumnCryptoMetaData +columnCryptoMetaDataEncryptionWithColumnKey :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm Format.ColumnCryptoMetaData +columnCryptoMetaDataEncryptionWithColumnKey x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "encryptionWithColumnKey"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the encryptionWithFooterKey variant of hydra.ext.parquet.format.ColumnCryptoMetaData +columnCryptoMetaDataEncryptionWithFooterKey :: Typed.TypedTerm Format.EncryptionWithFooterKey -> Typed.TypedTerm Format.ColumnCryptoMetaData +columnCryptoMetaDataEncryptionWithFooterKey x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "encryptionWithFooterKey"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.parquet.format.ColumnIndex +columnIndex :: Typed.TypedTerm [Bool] -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.BoundaryOrder -> Typed.TypedTerm (Maybe [I.Int64]) -> Typed.TypedTerm Format.ColumnIndex +columnIndex nullPages minValues maxValues boundaryOrder nullCounts = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Typed.unTypedTerm nullPages)}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Typed.unTypedTerm minValues)}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Typed.unTypedTerm maxValues)}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Typed.unTypedTerm boundaryOrder)}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Typed.unTypedTerm nullCounts)}]})) + +-- | DSL accessor for the boundaryOrder field of hydra.ext.parquet.format.ColumnIndex +columnIndexBoundaryOrder :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm Format.BoundaryOrder +columnIndexBoundaryOrder x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "boundaryOrder")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.ColumnIndex +columnIndexColumnIndex :: Typed.TypedName Format.ColumnIndex +columnIndexColumnIndex = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnIndex") + +-- | DSL accessor for the maxValues field of hydra.ext.parquet.format.ColumnIndex +columnIndexMaxValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] +columnIndexMaxValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "maxValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the minValues field of hydra.ext.parquet.format.ColumnIndex +columnIndexMinValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] +columnIndexMinValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "minValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nullCounts field of hydra.ext.parquet.format.ColumnIndex +columnIndexNullCounts :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm (Maybe [I.Int64]) +columnIndexNullCounts x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullCounts")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nullPages field of hydra.ext.parquet.format.ColumnIndex +columnIndexNullPages :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [Bool] +columnIndexNullPages x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullPages")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the boundaryOrder field of hydra.ext.parquet.format.ColumnIndex +columnIndexWithBoundaryOrder :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm Format.BoundaryOrder -> Typed.TypedTerm Format.ColumnIndex +columnIndexWithBoundaryOrder original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullPages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "minValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "maxValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullCounts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the maxValues field of hydra.ext.parquet.format.ColumnIndex +columnIndexWithMaxValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.ColumnIndex +columnIndexWithMaxValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullPages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "minValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "boundaryOrder")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullCounts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the minValues field of hydra.ext.parquet.format.ColumnIndex +columnIndexWithMinValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.ColumnIndex +columnIndexWithMinValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullPages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "maxValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "boundaryOrder")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullCounts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nullCounts field of hydra.ext.parquet.format.ColumnIndex +columnIndexWithNullCounts :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm (Maybe [I.Int64]) -> Typed.TypedTerm Format.ColumnIndex +columnIndexWithNullCounts original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullPages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "minValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "maxValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "boundaryOrder")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the nullPages field of hydra.ext.parquet.format.ColumnIndex +columnIndexWithNullPages :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [Bool] -> Typed.TypedTerm Format.ColumnIndex +columnIndexWithNullPages original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullPages"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "minValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "minValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "maxValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "boundaryOrder"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "boundaryOrder")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullCounts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"), + Model.projectionFieldName = (Model.Name "nullCounts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.ColumnMetaData +columnMetaData :: Typed.TypedTerm Format.Type -> Typed.TypedTerm [Format.Encoding] -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.CompressionCodec -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm (Maybe [Format.PageEncodingStats]) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaData type_ encodings pathInSchema codec numValues totalUncompressedSize totalCompressedSize keyValueMetadata dataPageOffset indexPageOffset dictionaryPageOffset statistics encodingStats bloomFilterOffset = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Typed.unTypedTerm encodings)}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Typed.unTypedTerm pathInSchema)}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Typed.unTypedTerm codec)}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm numValues)}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm totalUncompressedSize)}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm totalCompressedSize)}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Typed.unTypedTerm keyValueMetadata)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm dataPageOffset)}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm indexPageOffset)}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm dictionaryPageOffset)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm statistics)}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Typed.unTypedTerm encodingStats)}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Typed.unTypedTerm bloomFilterOffset)}]})) + +-- | DSL accessor for the bloomFilterOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataBloomFilterOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) +columnMetaDataBloomFilterOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the codec field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataCodec :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.CompressionCodec +columnMetaDataCodec x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.ColumnMetaData +columnMetaDataColumnMetaData :: Typed.TypedName Format.ColumnMetaData +columnMetaDataColumnMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnMetaData") + +-- | DSL accessor for the dataPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataDataPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 +columnMetaDataDataPageOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dictionaryPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataDictionaryPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) +columnMetaDataDictionaryPageOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encodingStats field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataEncodingStats :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.PageEncodingStats]) +columnMetaDataEncodingStats x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encodings field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataEncodings :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [Format.Encoding] +columnMetaDataEncodings x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the indexPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataIndexPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) +columnMetaDataIndexPageOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the keyValueMetadata field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataKeyValueMetadata :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) +columnMetaDataKeyValueMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numValues field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataNumValues :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 +columnMetaDataNumValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pathInSchema field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataPathInSchema :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [String] +columnMetaDataPathInSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the statistics field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataStatistics :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe Format.Statistics) +columnMetaDataStatistics x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the totalCompressedSize field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataTotalCompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 +columnMetaDataTotalCompressedSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the totalUncompressedSize field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataTotalUncompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 +columnMetaDataTotalUncompressedSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataType :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.Type +columnMetaDataType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the bloomFilterOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithBloomFilterOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithBloomFilterOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the codec field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithCodec :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.CompressionCodec -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithCodec original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dataPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithDataPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithDataPageOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dictionaryPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithDictionaryPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithDictionaryPageOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encodingStats field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithEncodingStats :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.PageEncodingStats]) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithEncodingStats original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encodings field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithEncodings :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [Format.Encoding] -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithEncodings original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the indexPageOffset field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithIndexPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithIndexPageOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the keyValueMetadata field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithKeyValueMetadata :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithKeyValueMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numValues field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithNumValues :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithNumValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pathInSchema field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithPathInSchema :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithPathInSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statistics field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithStatistics :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithStatistics original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the totalCompressedSize field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithTotalCompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithTotalCompressedSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the totalUncompressedSize field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithTotalUncompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithTotalUncompressedSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.parquet.format.ColumnMetaData +columnMetaDataWithType :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.Type -> Typed.TypedTerm Format.ColumnMetaData +columnMetaDataWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encodings"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodings")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "codec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "codec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalUncompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalUncompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dataPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "indexPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encodingStats"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "encodingStats")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "bloomFilterOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"), + Model.projectionFieldName = (Model.Name "bloomFilterOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.parquet.format.ColumnOrder +columnOrderColumnOrder :: Typed.TypedName Format.ColumnOrder +columnOrderColumnOrder = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnOrder") + +-- | DSL injection for the typeOrder variant of hydra.ext.parquet.format.ColumnOrder +columnOrderTypeOrder :: Typed.TypedTerm Format.ColumnOrder +columnOrderTypeOrder = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnOrder"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeOrder"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the brotli variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecBrotli :: Typed.TypedTerm Format.CompressionCodec +compressionCodecBrotli = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "brotli"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.CompressionCodec +compressionCodecCompressionCodec :: Typed.TypedName Format.CompressionCodec +compressionCodecCompressionCodec = Typed.TypedName (Model.Name "hydra.ext.parquet.format.CompressionCodec") + +-- | DSL injection for the gzip variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecGzip :: Typed.TypedTerm Format.CompressionCodec +compressionCodecGzip = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "gzip"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lz4Raw variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecLz4Raw :: Typed.TypedTerm Format.CompressionCodec +compressionCodecLz4Raw = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lz4Raw"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the lzo variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecLzo :: Typed.TypedTerm Format.CompressionCodec +compressionCodecLzo = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "lzo"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the snappy variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecSnappy :: Typed.TypedTerm Format.CompressionCodec +compressionCodecSnappy = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "snappy"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uncompressed variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecUncompressed :: Typed.TypedTerm Format.CompressionCodec +compressionCodecUncompressed = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uncompressed"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the zstd variant of hydra.ext.parquet.format.CompressionCodec +compressionCodecZstd :: Typed.TypedTerm Format.CompressionCodec +compressionCodecZstd = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "zstd"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.parquet.format.DataPageHeader +dataPageHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeader +dataPageHeader numValues encoding definitionLevelEncoding repetitionLevelEncoding statistics = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm numValues)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm encoding)}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Typed.unTypedTerm definitionLevelEncoding)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Typed.unTypedTerm repetitionLevelEncoding)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm statistics)}]})) + +-- | DSL name token for hydra.ext.parquet.format.DataPageHeader +dataPageHeaderDataPageHeader :: Typed.TypedName Format.DataPageHeader +dataPageHeaderDataPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DataPageHeader") + +-- | DSL accessor for the definitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderDefinitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding +dataPageHeaderDefinitionLevelEncoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding +dataPageHeaderEncoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderNumValues :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Int +dataPageHeaderNumValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the repetitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderRepetitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding +dataPageHeaderRepetitionLevelEncoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the statistics field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderStatistics :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm (Maybe Format.Statistics) +dataPageHeaderStatistics x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2 :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2 numValues numNulls numRows encoding definitionLevelsByteLength repetitionLevelsByteLength isCompressed statistics = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm numValues)}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Typed.unTypedTerm numNulls)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm numRows)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm encoding)}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Typed.unTypedTerm definitionLevelsByteLength)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Typed.unTypedTerm repetitionLevelsByteLength)}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Typed.unTypedTerm isCompressed)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm statistics)}]})) + +-- | DSL name token for hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2DataPageHeaderV2 :: Typed.TypedName Format.DataPageHeaderV2 +dataPageHeaderV2DataPageHeaderV2 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2") + +-- | DSL accessor for the definitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2DefinitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int +dataPageHeaderV2DefinitionLevelsByteLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2Encoding :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Format.Encoding +dataPageHeaderV2Encoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isCompressed field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2IsCompressed :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Bool) +dataPageHeaderV2IsCompressed x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numNulls field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2NumNulls :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int +dataPageHeaderV2NumNulls x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numRows field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2NumRows :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int +dataPageHeaderV2NumRows x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2NumValues :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int +dataPageHeaderV2NumValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the repetitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2RepetitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int +dataPageHeaderV2RepetitionLevelsByteLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the statistics field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2Statistics :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Format.Statistics) +dataPageHeaderV2Statistics x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the definitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithDefinitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithDefinitionLevelsByteLength original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encoding field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithEncoding :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isCompressed field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithIsCompressed :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithIsCompressed original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numNulls field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithNumNulls :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithNumNulls original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numRows field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithNumRows :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithNumRows original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numValues field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithNumValues :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithNumValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the repetitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithRepetitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithRepetitionLevelsByteLength original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statistics field of hydra.ext.parquet.format.DataPageHeaderV2 +dataPageHeaderV2WithStatistics :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeaderV2 +dataPageHeaderV2WithStatistics original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numNulls"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numNulls")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelsByteLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isCompressed"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"), + Model.projectionFieldName = (Model.Name "isCompressed")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the definitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderWithDefinitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader +dataPageHeaderWithDefinitionLevelEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderWithEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader +dataPageHeaderWithEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numValues field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderWithNumValues :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeader +dataPageHeaderWithNumValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the repetitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderWithRepetitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader +dataPageHeaderWithRepetitionLevelEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "statistics")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the statistics field of hydra.ext.parquet.format.DataPageHeader +dataPageHeaderWithStatistics :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeader +dataPageHeaderWithStatistics original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "definitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionLevelEncoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"), + Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "statistics"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.DecimalType +decimalType :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DecimalType +decimalType scale precision = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Typed.unTypedTerm scale)}, + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Typed.unTypedTerm precision)}]})) + +-- | DSL name token for hydra.ext.parquet.format.DecimalType +decimalTypeDecimalType :: Typed.TypedName Format.DecimalType +decimalTypeDecimalType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DecimalType") + +-- | DSL accessor for the precision field of hydra.ext.parquet.format.DecimalType +decimalTypePrecision :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int +decimalTypePrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.projectionFieldName = (Model.Name "precision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the scale field of hydra.ext.parquet.format.DecimalType +decimalTypeScale :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int +decimalTypeScale x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.projectionFieldName = (Model.Name "scale")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the precision field of hydra.ext.parquet.format.DecimalType +decimalTypeWithPrecision :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DecimalType +decimalTypeWithPrecision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.projectionFieldName = (Model.Name "scale")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the scale field of hydra.ext.parquet.format.DecimalType +decimalTypeWithScale :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DecimalType +decimalTypeWithScale original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scale"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "precision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"), + Model.projectionFieldName = (Model.Name "precision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DictionaryPageHeader +dictionaryPageHeader numValues encoding isSorted = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm numValues)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm encoding)}, + Model.Field { + Model.fieldName = (Model.Name "isSorted"), + Model.fieldTerm = (Typed.unTypedTerm isSorted)}]})) + +-- | DSL name token for hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderDictionaryPageHeader :: Typed.TypedName Format.DictionaryPageHeader +dictionaryPageHeaderDictionaryPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader") + +-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderEncoding :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Format.Encoding +dictionaryPageHeaderEncoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the isSorted field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderIsSorted :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm (Maybe Bool) +dictionaryPageHeaderIsSorted x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "isSorted")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderNumValues :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Int +dictionaryPageHeaderNumValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the encoding field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderWithEncoding :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DictionaryPageHeader +dictionaryPageHeaderWithEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isSorted"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "isSorted")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isSorted field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderWithIsSorted :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DictionaryPageHeader +dictionaryPageHeaderWithIsSorted original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "numValues")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isSorted"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the numValues field of hydra.ext.parquet.format.DictionaryPageHeader +dictionaryPageHeaderWithNumValues :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DictionaryPageHeader +dictionaryPageHeaderWithNumValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "numValues"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isSorted"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"), + Model.projectionFieldName = (Model.Name "isSorted")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the bitPacked variant of hydra.ext.parquet.format.Encoding +encodingBitPacked :: Typed.TypedTerm Format.Encoding +encodingBitPacked = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bitPacked"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the byteStreamSplit variant of hydra.ext.parquet.format.Encoding +encodingByteStreamSplit :: Typed.TypedTerm Format.Encoding +encodingByteStreamSplit = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byteStreamSplit"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the deltaBinaryPacked variant of hydra.ext.parquet.format.Encoding +encodingDeltaBinaryPacked :: Typed.TypedTerm Format.Encoding +encodingDeltaBinaryPacked = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "deltaBinaryPacked"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the deltaByteArray variant of hydra.ext.parquet.format.Encoding +encodingDeltaByteArray :: Typed.TypedTerm Format.Encoding +encodingDeltaByteArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "deltaByteArray"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the deltaLengthByteArray variant of hydra.ext.parquet.format.Encoding +encodingDeltaLengthByteArray :: Typed.TypedTerm Format.Encoding +encodingDeltaLengthByteArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "deltaLengthByteArray"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.Encoding +encodingEncoding :: Typed.TypedName Format.Encoding +encodingEncoding = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Encoding") + +-- | DSL injection for the plain variant of hydra.ext.parquet.format.Encoding +encodingPlain :: Typed.TypedTerm Format.Encoding +encodingPlain = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "plain"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rle variant of hydra.ext.parquet.format.Encoding +encodingRle :: Typed.TypedTerm Format.Encoding +encodingRle = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rle"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the rleDictionary variant of hydra.ext.parquet.format.Encoding +encodingRleDictionary :: Typed.TypedTerm Format.Encoding +encodingRleDictionary = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "rleDictionary"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the aesGcmCtrV1 variant of hydra.ext.parquet.format.EncryptionAlgorithm +encryptionAlgorithmAesGcmCtrV1 :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm Format.EncryptionAlgorithm +encryptionAlgorithmAesGcmCtrV1 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "aesGcmCtrV1"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the aesGcmV1 variant of hydra.ext.parquet.format.EncryptionAlgorithm +encryptionAlgorithmAesGcmV1 :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm Format.EncryptionAlgorithm +encryptionAlgorithmAesGcmV1 x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "aesGcmV1"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.parquet.format.EncryptionAlgorithm +encryptionAlgorithmEncryptionAlgorithm :: Typed.TypedName Format.EncryptionAlgorithm +encryptionAlgorithmEncryptionAlgorithm = Typed.TypedName (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm") + +-- | DSL constructor for hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKey :: Typed.TypedTerm [String] -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.EncryptionWithColumnKey +encryptionWithColumnKey pathInSchema keyMetadata = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Typed.unTypedTerm pathInSchema)}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm keyMetadata)}]})) + +-- | DSL name token for hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKeyEncryptionWithColumnKey :: Typed.TypedName Format.EncryptionWithColumnKey +encryptionWithColumnKeyEncryptionWithColumnKey = + Typed.TypedName (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey") + +-- | DSL accessor for the keyMetadata field of hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKeyKeyMetadata :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm (Maybe B.ByteString) +encryptionWithColumnKeyKeyMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.projectionFieldName = (Model.Name "keyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the pathInSchema field of hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKeyPathInSchema :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm [String] +encryptionWithColumnKeyPathInSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the keyMetadata field of hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKeyWithKeyMetadata :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.EncryptionWithColumnKey +encryptionWithColumnKeyWithKeyMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.projectionFieldName = (Model.Name "pathInSchema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the pathInSchema field of hydra.ext.parquet.format.EncryptionWithColumnKey +encryptionWithColumnKeyWithPathInSchema :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.EncryptionWithColumnKey +encryptionWithColumnKeyWithPathInSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pathInSchema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"), + Model.projectionFieldName = (Model.Name "keyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.parquet.format.FieldRepetitionType +fieldRepetitionTypeFieldRepetitionType :: Typed.TypedName Format.FieldRepetitionType +fieldRepetitionTypeFieldRepetitionType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FieldRepetitionType") + +-- | DSL injection for the optional variant of hydra.ext.parquet.format.FieldRepetitionType +fieldRepetitionTypeOptional :: Typed.TypedTerm Format.FieldRepetitionType +fieldRepetitionTypeOptional = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the repeated variant of hydra.ext.parquet.format.FieldRepetitionType +fieldRepetitionTypeRepeated :: Typed.TypedTerm Format.FieldRepetitionType +fieldRepetitionTypeRepeated = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "repeated"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the required variant of hydra.ext.parquet.format.FieldRepetitionType +fieldRepetitionTypeRequired :: Typed.TypedTerm Format.FieldRepetitionType +fieldRepetitionTypeRequired = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "required"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaData :: Typed.TypedTerm Format.EncryptionAlgorithm -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileCryptoMetaData +fileCryptoMetaData encryptionAlgorithm keyMetadata = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Typed.unTypedTerm encryptionAlgorithm)}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm keyMetadata)}]})) + +-- | DSL accessor for the encryptionAlgorithm field of hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaDataEncryptionAlgorithm :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm Format.EncryptionAlgorithm +fileCryptoMetaDataEncryptionAlgorithm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaDataFileCryptoMetaData :: Typed.TypedName Format.FileCryptoMetaData +fileCryptoMetaDataFileCryptoMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData") + +-- | DSL accessor for the keyMetadata field of hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaDataKeyMetadata :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm (Maybe B.ByteString) +fileCryptoMetaDataKeyMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.projectionFieldName = (Model.Name "keyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the encryptionAlgorithm field of hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaDataWithEncryptionAlgorithm :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm Format.EncryptionAlgorithm -> Typed.TypedTerm Format.FileCryptoMetaData +fileCryptoMetaDataWithEncryptionAlgorithm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.projectionFieldName = (Model.Name "keyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the keyMetadata field of hydra.ext.parquet.format.FileCryptoMetaData +fileCryptoMetaDataWithKeyMetadata :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileCryptoMetaData +fileCryptoMetaDataWithKeyMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.FileMetaData +fileMetaData :: Typed.TypedTerm Int -> Typed.TypedTerm [Format.SchemaElement] -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm [Format.RowGroup] -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe [Format.ColumnOrder]) -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileMetaData +fileMetaData version schema numRows rowGroups keyValueMetadata createdBy columnOrders encryptionAlgorithm footerSigningKeyMetadata = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Typed.unTypedTerm version)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm schema)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm numRows)}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Typed.unTypedTerm rowGroups)}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Typed.unTypedTerm keyValueMetadata)}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Typed.unTypedTerm createdBy)}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Typed.unTypedTerm columnOrders)}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Typed.unTypedTerm encryptionAlgorithm)}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm footerSigningKeyMetadata)}]})) + +-- | DSL accessor for the columnOrders field of hydra.ext.parquet.format.FileMetaData +fileMetaDataColumnOrders :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.ColumnOrder]) +fileMetaDataColumnOrders x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the createdBy field of hydra.ext.parquet.format.FileMetaData +fileMetaDataCreatedBy :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe String) +fileMetaDataCreatedBy x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encryptionAlgorithm field of hydra.ext.parquet.format.FileMetaData +fileMetaDataEncryptionAlgorithm :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm) +fileMetaDataEncryptionAlgorithm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.FileMetaData +fileMetaDataFileMetaData :: Typed.TypedName Format.FileMetaData +fileMetaDataFileMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FileMetaData") + +-- | DSL accessor for the footerSigningKeyMetadata field of hydra.ext.parquet.format.FileMetaData +fileMetaDataFooterSigningKeyMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe B.ByteString) +fileMetaDataFooterSigningKeyMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the keyValueMetadata field of hydra.ext.parquet.format.FileMetaData +fileMetaDataKeyValueMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) +fileMetaDataKeyValueMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numRows field of hydra.ext.parquet.format.FileMetaData +fileMetaDataNumRows :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm I.Int64 +fileMetaDataNumRows x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rowGroups field of hydra.ext.parquet.format.FileMetaData +fileMetaDataRowGroups :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.RowGroup] +fileMetaDataRowGroups x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schema field of hydra.ext.parquet.format.FileMetaData +fileMetaDataSchema :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.SchemaElement] +fileMetaDataSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the version field of hydra.ext.parquet.format.FileMetaData +fileMetaDataVersion :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm Int +fileMetaDataVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the columnOrders field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithColumnOrders :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.ColumnOrder]) -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithColumnOrders original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the createdBy field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithCreatedBy :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithCreatedBy original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the encryptionAlgorithm field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithEncryptionAlgorithm :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm) -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithEncryptionAlgorithm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the footerSigningKeyMetadata field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithFooterSigningKeyMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithFooterSigningKeyMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the keyValueMetadata field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithKeyValueMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithKeyValueMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numRows field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithNumRows :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithNumRows original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rowGroups field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithRowGroups :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.RowGroup] -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithRowGroups original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schema field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithSchema :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.SchemaElement] -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithSchema original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "version")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the version field of hydra.ext.parquet.format.FileMetaData +fileMetaDataWithVersion :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm Int -> Typed.TypedTerm Format.FileMetaData +fileMetaDataWithVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schema"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "schema")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rowGroups"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "rowGroups")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keyValueMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "keyValueMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "createdBy"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "createdBy")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnOrders"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "columnOrders")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encryptionAlgorithm"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "footerSigningKeyMetadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"), + Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.IntType +intType :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.IntType +intType bitWidth isSigned = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bitWidth"), + Model.fieldTerm = (Typed.unTypedTerm bitWidth)}, + Model.Field { + Model.fieldName = (Model.Name "isSigned"), + Model.fieldTerm = (Typed.unTypedTerm isSigned)}]})) + +-- | DSL accessor for the bitWidth field of hydra.ext.parquet.format.IntType +intTypeBitWidth :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm I.Int16 +intTypeBitWidth x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.projectionFieldName = (Model.Name "bitWidth")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.IntType +intTypeIntType :: Typed.TypedName Format.IntType +intTypeIntType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.IntType") + +-- | DSL accessor for the isSigned field of hydra.ext.parquet.format.IntType +intTypeIsSigned :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Bool +intTypeIsSigned x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.projectionFieldName = (Model.Name "isSigned")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the bitWidth field of hydra.ext.parquet.format.IntType +intTypeWithBitWidth :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm I.Int16 -> Typed.TypedTerm Format.IntType +intTypeWithBitWidth original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bitWidth"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "isSigned"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.projectionFieldName = (Model.Name "isSigned")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the isSigned field of hydra.ext.parquet.format.IntType +intTypeWithIsSigned :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.IntType +intTypeWithIsSigned original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "bitWidth"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"), + Model.projectionFieldName = (Model.Name "bitWidth")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "isSigned"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.KeyValue +keyValue :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.KeyValue +keyValue key value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the key field of hydra.ext.parquet.format.KeyValue +keyValueKey :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm String +keyValueKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.KeyValue +keyValueKeyValue :: Typed.TypedName Format.KeyValue +keyValueKeyValue = Typed.TypedName (Model.Name "hydra.ext.parquet.format.KeyValue") + +-- | DSL accessor for the value field of hydra.ext.parquet.format.KeyValue +keyValueValue :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm (Maybe String) +keyValueValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the key field of hydra.ext.parquet.format.KeyValue +keyValueWithKey :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm String -> Typed.TypedTerm Format.KeyValue +keyValueWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.parquet.format.KeyValue +keyValueWithValue :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.KeyValue +keyValueWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the bson variant of hydra.ext.parquet.format.LogicalType +logicalTypeBson :: Typed.TypedTerm Format.LogicalType +logicalTypeBson = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bson"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the date variant of hydra.ext.parquet.format.LogicalType +logicalTypeDate :: Typed.TypedTerm Format.LogicalType +logicalTypeDate = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "date"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the decimal variant of hydra.ext.parquet.format.LogicalType +logicalTypeDecimal :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Format.LogicalType +logicalTypeDecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the enum variant of hydra.ext.parquet.format.LogicalType +logicalTypeEnum :: Typed.TypedTerm Format.LogicalType +logicalTypeEnum = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the integer variant of hydra.ext.parquet.format.LogicalType +logicalTypeInteger :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Format.LogicalType +logicalTypeInteger x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the json variant of hydra.ext.parquet.format.LogicalType +logicalTypeJson :: Typed.TypedTerm Format.LogicalType +logicalTypeJson = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "json"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the list variant of hydra.ext.parquet.format.LogicalType +logicalTypeList :: Typed.TypedTerm Format.LogicalType +logicalTypeList = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.LogicalType +logicalTypeLogicalType :: Typed.TypedName Format.LogicalType +logicalTypeLogicalType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.LogicalType") + +-- | DSL injection for the map variant of hydra.ext.parquet.format.LogicalType +logicalTypeMap :: Typed.TypedTerm Format.LogicalType +logicalTypeMap = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.parquet.format.LogicalType +logicalTypeString :: Typed.TypedTerm Format.LogicalType +logicalTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the time variant of hydra.ext.parquet.format.LogicalType +logicalTypeTime :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.LogicalType +logicalTypeTime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "time"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the timestamp variant of hydra.ext.parquet.format.LogicalType +logicalTypeTimestamp :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.LogicalType +logicalTypeTimestamp x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unknown variant of hydra.ext.parquet.format.LogicalType +logicalTypeUnknown :: Typed.TypedTerm Format.LogicalType +logicalTypeUnknown = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unknown"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uuid variant of hydra.ext.parquet.format.LogicalType +logicalTypeUuid :: Typed.TypedTerm Format.LogicalType +logicalTypeUuid = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uuid"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.parquet.format.OffsetIndex +offsetIndex :: Typed.TypedTerm [Format.PageLocation] -> Typed.TypedTerm Format.OffsetIndex +offsetIndex pageLocations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageLocations"), + Model.fieldTerm = (Typed.unTypedTerm pageLocations)}]})) + +-- | DSL name token for hydra.ext.parquet.format.OffsetIndex +offsetIndexOffsetIndex :: Typed.TypedName Format.OffsetIndex +offsetIndexOffsetIndex = Typed.TypedName (Model.Name "hydra.ext.parquet.format.OffsetIndex") + +-- | DSL accessor for the pageLocations field of hydra.ext.parquet.format.OffsetIndex +offsetIndexPageLocations :: Typed.TypedTerm Format.OffsetIndex -> Typed.TypedTerm [Format.PageLocation] +offsetIndexPageLocations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"), + Model.projectionFieldName = (Model.Name "pageLocations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the pageLocations field of hydra.ext.parquet.format.OffsetIndex +offsetIndexWithPageLocations :: Typed.TypedTerm Format.OffsetIndex -> Typed.TypedTerm [Format.PageLocation] -> Typed.TypedTerm Format.OffsetIndex +offsetIndexWithPageLocations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageLocations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.PageEncodingStats +pageEncodingStats :: Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageEncodingStats +pageEncodingStats pageType encoding count = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageType"), + Model.fieldTerm = (Typed.unTypedTerm pageType)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm encoding)}, + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Typed.unTypedTerm count)}]})) + +-- | DSL accessor for the count field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsCount :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Int +pageEncodingStatsCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "count")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the encoding field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsEncoding :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.Encoding +pageEncodingStatsEncoding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsPageEncodingStats :: Typed.TypedName Format.PageEncodingStats +pageEncodingStatsPageEncodingStats = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageEncodingStats") + +-- | DSL accessor for the pageType field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsPageType :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.PageType +pageEncodingStatsPageType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "pageType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the count field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsWithCount :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageEncodingStats +pageEncodingStatsWithCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "pageType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the encoding field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsWithEncoding :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.PageEncodingStats +pageEncodingStatsWithEncoding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "pageType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "count")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the pageType field of hydra.ext.parquet.format.PageEncodingStats +pageEncodingStatsWithPageType :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.PageEncodingStats +pageEncodingStatsWithPageType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "pageType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "encoding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "encoding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "count"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"), + Model.projectionFieldName = (Model.Name "count")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.PageHeader +pageHeader :: Typed.TypedTerm Format.PageType -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.DataPageHeader) -> Typed.TypedTerm (Maybe Format.IndexPageHeader) -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader) -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2) -> Typed.TypedTerm Format.PageHeader +pageHeader type_ uncompressedPageSize compressedPageSize crc dataPageHeader indexPageHeader dictionaryPageHeader dataPageHeaderV2 = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm uncompressedPageSize)}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm compressedPageSize)}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Typed.unTypedTerm crc)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm dataPageHeader)}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm indexPageHeader)}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm dictionaryPageHeader)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Typed.unTypedTerm dataPageHeaderV2)}]})) + +-- | DSL accessor for the compressedPageSize field of hydra.ext.parquet.format.PageHeader +pageHeaderCompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int +pageHeaderCompressedPageSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the crc field of hydra.ext.parquet.format.PageHeader +pageHeaderCrc :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Int) +pageHeaderCrc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dataPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderDataPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeader) +pageHeaderDataPageHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dataPageHeaderV2 field of hydra.ext.parquet.format.PageHeader +pageHeaderDataPageHeaderV2 :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2) +pageHeaderDataPageHeaderV2 x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the dictionaryPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderDictionaryPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader) +pageHeaderDictionaryPageHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the indexPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderIndexPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.IndexPageHeader) +pageHeaderIndexPageHeader x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.PageHeader +pageHeaderPageHeader :: Typed.TypedName Format.PageHeader +pageHeaderPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageHeader") + +-- | DSL accessor for the type field of hydra.ext.parquet.format.PageHeader +pageHeaderType :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Format.PageType +pageHeaderType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the uncompressedPageSize field of hydra.ext.parquet.format.PageHeader +pageHeaderUncompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int +pageHeaderUncompressedPageSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the compressedPageSize field of hydra.ext.parquet.format.PageHeader +pageHeaderWithCompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageHeader +pageHeaderWithCompressedPageSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the crc field of hydra.ext.parquet.format.PageHeader +pageHeaderWithCrc :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.PageHeader +pageHeaderWithCrc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dataPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderWithDataPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeader) -> Typed.TypedTerm Format.PageHeader +pageHeaderWithDataPageHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the dataPageHeaderV2 field of hydra.ext.parquet.format.PageHeader +pageHeaderWithDataPageHeaderV2 :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2) -> Typed.TypedTerm Format.PageHeader +pageHeaderWithDataPageHeaderV2 original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the dictionaryPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderWithDictionaryPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader) -> Typed.TypedTerm Format.PageHeader +pageHeaderWithDictionaryPageHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the indexPageHeader field of hydra.ext.parquet.format.PageHeader +pageHeaderWithIndexPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.IndexPageHeader) -> Typed.TypedTerm Format.PageHeader +pageHeaderWithIndexPageHeader original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.parquet.format.PageHeader +pageHeaderWithType :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.PageHeader +pageHeaderWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "uncompressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the uncompressedPageSize field of hydra.ext.parquet.format.PageHeader +pageHeaderWithUncompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageHeader +pageHeaderWithUncompressedPageSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "uncompressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "crc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "crc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "indexPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "indexPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dictionaryPageHeader"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dataPageHeaderV2"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"), + Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.PageLocation +pageLocation :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Int -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation +pageLocation offset compressedPageSize firstRowIndex = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "offset"), + Model.fieldTerm = (Typed.unTypedTerm offset)}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm compressedPageSize)}, + Model.Field { + Model.fieldName = (Model.Name "firstRowIndex"), + Model.fieldTerm = (Typed.unTypedTerm firstRowIndex)}]})) + +-- | DSL accessor for the compressedPageSize field of hydra.ext.parquet.format.PageLocation +pageLocationCompressedPageSize :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm Int +pageLocationCompressedPageSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the firstRowIndex field of hydra.ext.parquet.format.PageLocation +pageLocationFirstRowIndex :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 +pageLocationFirstRowIndex x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "firstRowIndex")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the offset field of hydra.ext.parquet.format.PageLocation +pageLocationOffset :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 +pageLocationOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "offset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.PageLocation +pageLocationPageLocation :: Typed.TypedName Format.PageLocation +pageLocationPageLocation = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageLocation") + +-- | DSL updater for the compressedPageSize field of hydra.ext.parquet.format.PageLocation +pageLocationWithCompressedPageSize :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageLocation +pageLocationWithCompressedPageSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "offset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "offset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "firstRowIndex"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "firstRowIndex")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the firstRowIndex field of hydra.ext.parquet.format.PageLocation +pageLocationWithFirstRowIndex :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation +pageLocationWithFirstRowIndex original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "offset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "offset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "firstRowIndex"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the offset field of hydra.ext.parquet.format.PageLocation +pageLocationWithOffset :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation +pageLocationWithOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "offset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "compressedPageSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "compressedPageSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "firstRowIndex"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"), + Model.projectionFieldName = (Model.Name "firstRowIndex")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the dataPage variant of hydra.ext.parquet.format.PageType +pageTypeDataPage :: Typed.TypedTerm Format.PageType +pageTypeDataPage = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dataPage"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dataPageV2 variant of hydra.ext.parquet.format.PageType +pageTypeDataPageV2 :: Typed.TypedTerm Format.PageType +pageTypeDataPageV2 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dataPageV2"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dictionaryPage variant of hydra.ext.parquet.format.PageType +pageTypeDictionaryPage :: Typed.TypedTerm Format.PageType +pageTypeDictionaryPage = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dictionaryPage"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the indexPage variant of hydra.ext.parquet.format.PageType +pageTypeIndexPage :: Typed.TypedTerm Format.PageType +pageTypeIndexPage = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "indexPage"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.PageType +pageTypePageType :: Typed.TypedName Format.PageType +pageTypePageType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageType") + +-- | DSL constructor for hydra.ext.parquet.format.RowGroup +rowGroup :: Typed.TypedTerm [Format.ColumnChunk] -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe [Format.SortingColumn]) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int16) -> Typed.TypedTerm Format.RowGroup +rowGroup columns totalByteSize numRows sortingColumns fileOffset totalCompressedSize ordinal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm columns)}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Typed.unTypedTerm totalByteSize)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm numRows)}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Typed.unTypedTerm sortingColumns)}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Typed.unTypedTerm fileOffset)}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm totalCompressedSize)}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Typed.unTypedTerm ordinal)}]})) + +-- | DSL accessor for the columns field of hydra.ext.parquet.format.RowGroup +rowGroupColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm [Format.ColumnChunk] +rowGroupColumns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the fileOffset field of hydra.ext.parquet.format.RowGroup +rowGroupFileOffset :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) +rowGroupFileOffset x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numRows field of hydra.ext.parquet.format.RowGroup +rowGroupNumRows :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 +rowGroupNumRows x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ordinal field of hydra.ext.parquet.format.RowGroup +rowGroupOrdinal :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int16) +rowGroupOrdinal x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.RowGroup +rowGroupRowGroup :: Typed.TypedName Format.RowGroup +rowGroupRowGroup = Typed.TypedName (Model.Name "hydra.ext.parquet.format.RowGroup") + +-- | DSL accessor for the sortingColumns field of hydra.ext.parquet.format.RowGroup +rowGroupSortingColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe [Format.SortingColumn]) +rowGroupSortingColumns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the totalByteSize field of hydra.ext.parquet.format.RowGroup +rowGroupTotalByteSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 +rowGroupTotalByteSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the totalCompressedSize field of hydra.ext.parquet.format.RowGroup +rowGroupTotalCompressedSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) +rowGroupTotalCompressedSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the columns field of hydra.ext.parquet.format.RowGroup +rowGroupWithColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm [Format.ColumnChunk] -> Typed.TypedTerm Format.RowGroup +rowGroupWithColumns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the fileOffset field of hydra.ext.parquet.format.RowGroup +rowGroupWithFileOffset :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.RowGroup +rowGroupWithFileOffset original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numRows field of hydra.ext.parquet.format.RowGroup +rowGroupWithNumRows :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.RowGroup +rowGroupWithNumRows original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ordinal field of hydra.ext.parquet.format.RowGroup +rowGroupWithOrdinal :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int16) -> Typed.TypedTerm Format.RowGroup +rowGroupWithOrdinal original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the sortingColumns field of hydra.ext.parquet.format.RowGroup +rowGroupWithSortingColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe [Format.SortingColumn]) -> Typed.TypedTerm Format.RowGroup +rowGroupWithSortingColumns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the totalByteSize field of hydra.ext.parquet.format.RowGroup +rowGroupWithTotalByteSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.RowGroup +rowGroupWithTotalByteSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalCompressedSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the totalCompressedSize field of hydra.ext.parquet.format.RowGroup +rowGroupWithTotalCompressedSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.RowGroup +rowGroupWithTotalCompressedSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalByteSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "totalByteSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numRows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "numRows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sortingColumns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "sortingColumns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fileOffset"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "fileOffset")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "totalCompressedSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ordinal"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"), + Model.projectionFieldName = (Model.Name "ordinal")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.SchemaElement +schemaElement :: Typed.TypedTerm (Maybe Format.Type) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.FieldRepetitionType) -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.LogicalType) -> Typed.TypedTerm Format.SchemaElement +schemaElement type_ typeLength repetitionType name numChildren fieldId logicalType = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Typed.unTypedTerm typeLength)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Typed.unTypedTerm repetitionType)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Typed.unTypedTerm numChildren)}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Typed.unTypedTerm fieldId)}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Typed.unTypedTerm logicalType)}]})) + +-- | DSL accessor for the fieldId field of hydra.ext.parquet.format.SchemaElement +schemaElementFieldId :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) +schemaElementFieldId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the logicalType field of hydra.ext.parquet.format.SchemaElement +schemaElementLogicalType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.LogicalType) +schemaElementLogicalType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.parquet.format.SchemaElement +schemaElementName :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm String +schemaElementName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the numChildren field of hydra.ext.parquet.format.SchemaElement +schemaElementNumChildren :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) +schemaElementNumChildren x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the repetitionType field of hydra.ext.parquet.format.SchemaElement +schemaElementRepetitionType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.FieldRepetitionType) +schemaElementRepetitionType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.SchemaElement +schemaElementSchemaElement :: Typed.TypedName Format.SchemaElement +schemaElementSchemaElement = Typed.TypedName (Model.Name "hydra.ext.parquet.format.SchemaElement") + +-- | DSL accessor for the type field of hydra.ext.parquet.format.SchemaElement +schemaElementType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.Type) +schemaElementType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeLength field of hydra.ext.parquet.format.SchemaElement +schemaElementTypeLength :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) +schemaElementTypeLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the fieldId field of hydra.ext.parquet.format.SchemaElement +schemaElementWithFieldId :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithFieldId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the logicalType field of hydra.ext.parquet.format.SchemaElement +schemaElementWithLogicalType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.LogicalType) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithLogicalType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.parquet.format.SchemaElement +schemaElementWithName :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm String -> Typed.TypedTerm Format.SchemaElement +schemaElementWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the numChildren field of hydra.ext.parquet.format.SchemaElement +schemaElementWithNumChildren :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithNumChildren original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the repetitionType field of hydra.ext.parquet.format.SchemaElement +schemaElementWithRepetitionType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.FieldRepetitionType) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithRepetitionType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.parquet.format.SchemaElement +schemaElementWithType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.Type) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "typeLength")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeLength field of hydra.ext.parquet.format.SchemaElement +schemaElementWithTypeLength :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement +schemaElementWithTypeLength original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeLength"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "repetitionType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "repetitionType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "numChildren"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "numChildren")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "fieldId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "logicalType"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"), + Model.projectionFieldName = (Model.Name "logicalType")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.SortingColumn +sortingColumn :: Typed.TypedTerm Int -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn +sortingColumn columnIdx descending nullsFirst = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columnIdx"), + Model.fieldTerm = (Typed.unTypedTerm columnIdx)}, + Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = (Typed.unTypedTerm descending)}, + Model.Field { + Model.fieldName = (Model.Name "nullsFirst"), + Model.fieldTerm = (Typed.unTypedTerm nullsFirst)}]})) + +-- | DSL accessor for the columnIdx field of hydra.ext.parquet.format.SortingColumn +sortingColumnColumnIdx :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Int +sortingColumnColumnIdx x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "columnIdx")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the descending field of hydra.ext.parquet.format.SortingColumn +sortingColumnDescending :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool +sortingColumnDescending x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "descending")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nullsFirst field of hydra.ext.parquet.format.SortingColumn +sortingColumnNullsFirst :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool +sortingColumnNullsFirst x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "nullsFirst")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.SortingColumn +sortingColumnSortingColumn :: Typed.TypedName Format.SortingColumn +sortingColumnSortingColumn = Typed.TypedName (Model.Name "hydra.ext.parquet.format.SortingColumn") + +-- | DSL updater for the columnIdx field of hydra.ext.parquet.format.SortingColumn +sortingColumnWithColumnIdx :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Int -> Typed.TypedTerm Format.SortingColumn +sortingColumnWithColumnIdx original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columnIdx"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "descending")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullsFirst"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "nullsFirst")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the descending field of hydra.ext.parquet.format.SortingColumn +sortingColumnWithDescending :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn +sortingColumnWithDescending original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columnIdx"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "columnIdx")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nullsFirst"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "nullsFirst")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nullsFirst field of hydra.ext.parquet.format.SortingColumn +sortingColumnWithNullsFirst :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn +sortingColumnWithNullsFirst original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columnIdx"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "columnIdx")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "descending"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"), + Model.projectionFieldName = (Model.Name "descending")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nullsFirst"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.parquet.format.Statistics +statistics :: Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics +statistics nullCount distinctCount maxValue minValue = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullCount"), + Model.fieldTerm = (Typed.unTypedTerm nullCount)}, + Model.Field { + Model.fieldName = (Model.Name "distinctCount"), + Model.fieldTerm = (Typed.unTypedTerm distinctCount)}, + Model.Field { + Model.fieldName = (Model.Name "maxValue"), + Model.fieldTerm = (Typed.unTypedTerm maxValue)}, + Model.Field { + Model.fieldName = (Model.Name "minValue"), + Model.fieldTerm = (Typed.unTypedTerm minValue)}]})) + +-- | DSL accessor for the distinctCount field of hydra.ext.parquet.format.Statistics +statisticsDistinctCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) +statisticsDistinctCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "distinctCount")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the maxValue field of hydra.ext.parquet.format.Statistics +statisticsMaxValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) +statisticsMaxValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "maxValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the minValue field of hydra.ext.parquet.format.Statistics +statisticsMinValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) +statisticsMinValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "minValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nullCount field of hydra.ext.parquet.format.Statistics +statisticsNullCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) +statisticsNullCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "nullCount")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.Statistics +statisticsStatistics :: Typed.TypedName Format.Statistics +statisticsStatistics = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Statistics") + +-- | DSL updater for the distinctCount field of hydra.ext.parquet.format.Statistics +statisticsWithDistinctCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Format.Statistics +statisticsWithDistinctCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "nullCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "distinctCount"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "maxValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "maxValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "minValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the maxValue field of hydra.ext.parquet.format.Statistics +statisticsWithMaxValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics +statisticsWithMaxValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "nullCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "distinctCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "distinctCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "minValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "minValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the minValue field of hydra.ext.parquet.format.Statistics +statisticsWithMinValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics +statisticsWithMinValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "nullCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "distinctCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "distinctCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "maxValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the nullCount field of hydra.ext.parquet.format.Statistics +statisticsWithNullCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Format.Statistics +statisticsWithNullCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "nullCount"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "distinctCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "distinctCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "maxValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "maxValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "minValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"), + Model.projectionFieldName = (Model.Name "minValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.parquet.format.TimeType +timeType :: Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimeType +timeType isAdjustedToUtc unit = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Typed.unTypedTerm isAdjustedToUtc)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm unit)}]})) + +-- | DSL accessor for the isAdjustedToUtc field of hydra.ext.parquet.format.TimeType +timeTypeIsAdjustedToUtc :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Bool +timeTypeIsAdjustedToUtc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.TimeType +timeTypeTimeType :: Typed.TypedName Format.TimeType +timeTypeTimeType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimeType") + +-- | DSL accessor for the unit field of hydra.ext.parquet.format.TimeType +timeTypeUnit :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.TimeUnit +timeTypeUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the isAdjustedToUtc field of hydra.ext.parquet.format.TimeType +timeTypeWithIsAdjustedToUtc :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeType +timeTypeWithIsAdjustedToUtc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unit field of hydra.ext.parquet.format.TimeType +timeTypeWithUnit :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimeType +timeTypeWithUnit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"), + Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the micros variant of hydra.ext.parquet.format.TimeUnit +timeUnitMicros :: Typed.TypedTerm Format.TimeUnit +timeUnitMicros = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "micros"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the millis variant of hydra.ext.parquet.format.TimeUnit +timeUnitMillis :: Typed.TypedTerm Format.TimeUnit +timeUnitMillis = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "millis"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the nanos variant of hydra.ext.parquet.format.TimeUnit +timeUnitNanos :: Typed.TypedTerm Format.TimeUnit +timeUnitNanos = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nanos"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.TimeUnit +timeUnitTimeUnit :: Typed.TypedName Format.TimeUnit +timeUnitTimeUnit = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimeUnit") + +-- | DSL constructor for hydra.ext.parquet.format.TimestampType +timestampType :: Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimestampType +timestampType isAdjustedToUtc unit = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Typed.unTypedTerm isAdjustedToUtc)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm unit)}]})) + +-- | DSL accessor for the isAdjustedToUtc field of hydra.ext.parquet.format.TimestampType +timestampTypeIsAdjustedToUtc :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Bool +timestampTypeIsAdjustedToUtc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.parquet.format.TimestampType +timestampTypeTimestampType :: Typed.TypedName Format.TimestampType +timestampTypeTimestampType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimestampType") + +-- | DSL accessor for the unit field of hydra.ext.parquet.format.TimestampType +timestampTypeUnit :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.TimeUnit +timestampTypeUnit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the isAdjustedToUtc field of hydra.ext.parquet.format.TimestampType +timestampTypeWithIsAdjustedToUtc :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimestampType +timestampTypeWithIsAdjustedToUtc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.projectionFieldName = (Model.Name "unit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the unit field of hydra.ext.parquet.format.TimestampType +timestampTypeWithUnit :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimestampType +timestampTypeWithUnit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "isAdjustedToUtc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"), + Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "unit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the boolean variant of hydra.ext.parquet.format.Type +typeBoolean :: Typed.TypedTerm Format.Type +typeBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the byteArray variant of hydra.ext.parquet.format.Type +typeByteArray :: Typed.TypedTerm Format.Type +typeByteArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byteArray"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.parquet.format.Type +typeDouble :: Typed.TypedTerm Format.Type +typeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the fixedLenByteArray variant of hydra.ext.parquet.format.Type +typeFixedLenByteArray :: Typed.TypedTerm Format.Type +typeFixedLenByteArray = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixedLenByteArray"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.parquet.format.Type +typeFloat :: Typed.TypedTerm Format.Type +typeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int32 variant of hydra.ext.parquet.format.Type +typeInt32 :: Typed.TypedTerm Format.Type +typeInt32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int64 variant of hydra.ext.parquet.format.Type +typeInt64 :: Typed.TypedTerm Format.Type +typeInt64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.parquet.format.Type +typeType :: Typed.TypedName Format.Type +typeType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Type") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Pegasus/Pdl.hs b/src/main/haskell/Hydra/Ext/Dsl/Pegasus/Pdl.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Pegasus/Pdl.hs @@ -0,0 +1,1373 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.pegasus.pdl + +module Hydra.Ext.Dsl.Pegasus.Pdl where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Pegasus.Pdl as Pdl +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.pegasus.pdl.Annotations +annotations :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.Annotations +annotations doc deprecated = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm doc)}, + Model.Field { + Model.fieldName = (Model.Name "deprecated"), + Model.fieldTerm = (Typed.unTypedTerm deprecated)}]})) + +-- | DSL name token for hydra.ext.pegasus.pdl.Annotations +annotationsAnnotations :: Typed.TypedName Pdl.Annotations +annotationsAnnotations = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Annotations") + +-- | DSL accessor for the deprecated field of hydra.ext.pegasus.pdl.Annotations +annotationsDeprecated :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Bool +annotationsDeprecated x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.projectionFieldName = (Model.Name "deprecated")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the doc field of hydra.ext.pegasus.pdl.Annotations +annotationsDoc :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm (Maybe String) +annotationsDoc x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the deprecated field of hydra.ext.pegasus.pdl.Annotations +annotationsWithDeprecated :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.Annotations +annotationsWithDeprecated original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.projectionFieldName = (Model.Name "doc")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "deprecated"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the doc field of hydra.ext.pegasus.pdl.Annotations +annotationsWithDoc :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Pdl.Annotations +annotationsWithDoc original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "doc"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "deprecated"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"), + Model.projectionFieldName = (Model.Name "deprecated")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.EnumField +enumField :: Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.EnumField +enumField name annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.EnumField +enumFieldAnnotations :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.Annotations +enumFieldAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.EnumField +enumFieldEnumField :: Typed.TypedName Pdl.EnumField +enumFieldEnumField = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumField") + +-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.EnumField +enumFieldName :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.EnumFieldName +enumFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.pegasus.pdl.EnumFieldName wrapper +enumFieldName2 :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.EnumFieldName +enumFieldName2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.EnumFieldName +enumFieldNameEnumFieldName :: Typed.TypedName Pdl.EnumFieldName +enumFieldNameEnumFieldName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName") + +-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.EnumField +enumFieldWithAnnotations :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.EnumField +enumFieldWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.pegasus.pdl.EnumField +enumFieldWithName :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm Pdl.EnumField +enumFieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.EnumSchema +enumSchema :: Typed.TypedTerm [Pdl.EnumField] -> Typed.TypedTerm Pdl.EnumSchema +enumSchema fields = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}]})) + +-- | DSL name token for hydra.ext.pegasus.pdl.EnumSchema +enumSchemaEnumSchema :: Typed.TypedName Pdl.EnumSchema +enumSchemaEnumSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumSchema") + +-- | DSL accessor for the fields field of hydra.ext.pegasus.pdl.EnumSchema +enumSchemaFields :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm [Pdl.EnumField] +enumSchemaFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the fields field of hydra.ext.pegasus.pdl.EnumSchema +enumSchemaWithFields :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm [Pdl.EnumField] -> Typed.TypedTerm Pdl.EnumSchema +enumSchemaWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.pegasus.pdl.FieldName wrapper +fieldName :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.FieldName +fieldName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.FieldName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.FieldName +fieldNameFieldName :: Typed.TypedName Pdl.FieldName +fieldNameFieldName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.FieldName") + +-- | DSL constructor for the hydra.ext.pegasus.pdl.Name wrapper +name :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Name +name x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Name"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.Name +nameName :: Typed.TypedName Pdl.Name +nameName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Name") + +-- | DSL constructor for hydra.ext.pegasus.pdl.NamedSchema +namedSchema :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.NamedSchemaType -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.NamedSchema +namedSchema qualifiedName type_ annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "qualifiedName"), + Model.fieldTerm = (Typed.unTypedTerm qualifiedName)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaAnnotations :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Annotations +namedSchemaAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.NamedSchema +namedSchemaNamedSchema :: Typed.TypedName Pdl.NamedSchema +namedSchemaNamedSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.NamedSchema") + +-- | DSL accessor for the qualifiedName field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaQualifiedName :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.QualifiedName +namedSchemaQualifiedName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "qualifiedName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaType :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.NamedSchemaType +namedSchemaType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the enum variant of hydra.ext.pegasus.pdl.NamedSchemaType +namedSchemaTypeEnum :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm Pdl.NamedSchemaType +namedSchemaTypeEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.pegasus.pdl.NamedSchemaType +namedSchemaTypeNamedSchemaType :: Typed.TypedName Pdl.NamedSchemaType +namedSchemaTypeNamedSchemaType = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType") + +-- | DSL injection for the record variant of hydra.ext.pegasus.pdl.NamedSchemaType +namedSchemaTypeRecord :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm Pdl.NamedSchemaType +namedSchemaTypeRecord x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "record"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the typeref variant of hydra.ext.pegasus.pdl.NamedSchemaType +namedSchemaTypeTyperef :: Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.NamedSchemaType +namedSchemaTypeTyperef x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "typeref"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaWithAnnotations :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.NamedSchema +namedSchemaWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "qualifiedName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "qualifiedName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the qualifiedName field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaWithQualifiedName :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.NamedSchema +namedSchemaWithQualifiedName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "qualifiedName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.pegasus.pdl.NamedSchema +namedSchemaWithType :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.NamedSchemaType -> Typed.TypedTerm Pdl.NamedSchema +namedSchemaWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "qualifiedName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "qualifiedName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.pegasus.pdl.Namespace wrapper +namespace :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Namespace +namespace x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Namespace"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.Namespace +namespaceNamespace :: Typed.TypedName Pdl.Namespace +namespaceNamespace = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Namespace") + +-- | DSL constructor for the hydra.ext.pegasus.pdl.Package wrapper +package :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Package +package x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Package"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.Package +packagePackage :: Typed.TypedName Pdl.Package +packagePackage = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Package") + +-- | DSL injection for the boolean variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeBoolean :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeBoolean = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bytes variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeBytes :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeBytes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bytes"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeDouble :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeFloat :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeInt :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the long variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeLong :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeLong = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "long"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypePrimitiveType :: Typed.TypedName Pdl.PrimitiveType +primitiveTypePrimitiveType = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType") + +-- | DSL injection for the string variant of hydra.ext.pegasus.pdl.PrimitiveType +primitiveTypeString :: Typed.TypedTerm Pdl.PrimitiveType +primitiveTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.Property +property :: Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Property +property key value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm key)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the key field of hydra.ext.pegasus.pdl.Property +propertyKey :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm Pdl.PropertyKey +propertyKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.pegasus.pdl.PropertyKey wrapper +propertyKey2 :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.PropertyKey +propertyKey2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.PropertyKey"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.PropertyKey +propertyKeyPropertyKey :: Typed.TypedName Pdl.PropertyKey +propertyKeyPropertyKey = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.PropertyKey") + +-- | DSL name token for hydra.ext.pegasus.pdl.Property +propertyProperty :: Typed.TypedName Pdl.Property +propertyProperty = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Property") + +-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.Property +propertyValue :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm (Maybe JsonModel.Value) +propertyValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the key field of hydra.ext.pegasus.pdl.Property +propertyWithKey :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm Pdl.Property +propertyWithKey original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.pegasus.pdl.Property +propertyWithValue :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Property +propertyWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "key"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"), + Model.projectionFieldName = (Model.Name "key")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.QualifiedName +qualifiedName :: Typed.TypedTerm Pdl.Name -> Typed.TypedTerm (Maybe Pdl.Namespace) -> Typed.TypedTerm Pdl.QualifiedName +qualifiedName name namespace = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}]})) + +-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.QualifiedName +qualifiedNameName :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.Name +qualifiedNameName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespace field of hydra.ext.pegasus.pdl.QualifiedName +qualifiedNameNamespace :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm (Maybe Pdl.Namespace) +qualifiedNameNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.QualifiedName +qualifiedNameQualifiedName :: Typed.TypedName Pdl.QualifiedName +qualifiedNameQualifiedName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.QualifiedName") + +-- | DSL updater for the name field of hydra.ext.pegasus.pdl.QualifiedName +qualifiedNameWithName :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.Name -> Typed.TypedTerm Pdl.QualifiedName +qualifiedNameWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the namespace field of hydra.ext.pegasus.pdl.QualifiedName +qualifiedNameWithNamespace :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm (Maybe Pdl.Namespace) -> Typed.TypedTerm Pdl.QualifiedName +qualifiedNameWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.RecordField +recordField :: Typed.TypedTerm Pdl.FieldName -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.RecordField +recordField name value optional default_ annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Typed.unTypedTerm optional)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm default_)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.RecordField +recordFieldAnnotations :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Annotations +recordFieldAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the default field of hydra.ext.pegasus.pdl.RecordField +recordFieldDefault :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm (Maybe JsonModel.Value) +recordFieldDefault x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.RecordField +recordFieldName :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.FieldName +recordFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the optional field of hydra.ext.pegasus.pdl.RecordField +recordFieldOptional :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Bool +recordFieldOptional x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "optional")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.RecordField +recordFieldRecordField :: Typed.TypedName Pdl.RecordField +recordFieldRecordField = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.RecordField") + +-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.RecordField +recordFieldValue :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Schema +recordFieldValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.RecordField +recordFieldWithAnnotations :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.RecordField +recordFieldWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "optional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the default field of hydra.ext.pegasus.pdl.RecordField +recordFieldWithDefault :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.RecordField +recordFieldWithDefault original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "optional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.pegasus.pdl.RecordField +recordFieldWithName :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.FieldName -> Typed.TypedTerm Pdl.RecordField +recordFieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "optional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the optional field of hydra.ext.pegasus.pdl.RecordField +recordFieldWithOptional :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.RecordField +recordFieldWithOptional original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.pegasus.pdl.RecordField +recordFieldWithValue :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.RecordField +recordFieldWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "optional"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "optional")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "default")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.RecordSchema +recordSchema :: Typed.TypedTerm [Pdl.RecordField] -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.RecordSchema +recordSchema fields includes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Typed.unTypedTerm includes)}]})) + +-- | DSL accessor for the fields field of hydra.ext.pegasus.pdl.RecordSchema +recordSchemaFields :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.RecordField] +recordSchemaFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the includes field of hydra.ext.pegasus.pdl.RecordSchema +recordSchemaIncludes :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.NamedSchema] +recordSchemaIncludes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.projectionFieldName = (Model.Name "includes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.RecordSchema +recordSchemaRecordSchema :: Typed.TypedName Pdl.RecordSchema +recordSchemaRecordSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.RecordSchema") + +-- | DSL updater for the fields field of hydra.ext.pegasus.pdl.RecordSchema +recordSchemaWithFields :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.RecordField] -> Typed.TypedTerm Pdl.RecordSchema +recordSchemaWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.projectionFieldName = (Model.Name "includes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the includes field of hydra.ext.pegasus.pdl.RecordSchema +recordSchemaWithIncludes :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.RecordSchema +recordSchemaWithIncludes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "includes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the array variant of hydra.ext.pegasus.pdl.Schema +schemaArray :: Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.Schema +schemaArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.SchemaFile +schemaFile :: Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm (Maybe Pdl.Package) -> Typed.TypedTerm [Pdl.QualifiedName] -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.SchemaFile +schemaFile namespace package imports schemas = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm namespace)}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm package)}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Typed.unTypedTerm imports)}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Typed.unTypedTerm schemas)}]})) + +-- | DSL accessor for the imports field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileImports :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.QualifiedName] +schemaFileImports x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the namespace field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileNamespace :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm Pdl.Namespace +schemaFileNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the package field of hydra.ext.pegasus.pdl.SchemaFile +schemaFilePackage :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm (Maybe Pdl.Package) +schemaFilePackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.SchemaFile +schemaFileSchemaFile :: Typed.TypedName Pdl.SchemaFile +schemaFileSchemaFile = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.SchemaFile") + +-- | DSL accessor for the schemas field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileSchemas :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.NamedSchema] +schemaFileSchemas x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the imports field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileWithImports :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.QualifiedName] -> Typed.TypedTerm Pdl.SchemaFile +schemaFileWithImports original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the namespace field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileWithNamespace :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm Pdl.SchemaFile +schemaFileWithNamespace original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the package field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileWithPackage :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm (Maybe Pdl.Package) -> Typed.TypedTerm Pdl.SchemaFile +schemaFileWithPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "schemas")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schemas field of hydra.ext.pegasus.pdl.SchemaFile +schemaFileWithSchemas :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.SchemaFile +schemaFileWithSchemas original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "namespace"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "namespace")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemas"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the fixed variant of hydra.ext.pegasus.pdl.Schema +schemaFixed :: Typed.TypedTerm Int -> Typed.TypedTerm Pdl.Schema +schemaFixed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the inline variant of hydra.ext.pegasus.pdl.Schema +schemaInline :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Schema +schemaInline x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "inline"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the map variant of hydra.ext.pegasus.pdl.Schema +schemaMap :: Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.Schema +schemaMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the named variant of hydra.ext.pegasus.pdl.Schema +schemaNamed :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.Schema +schemaNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the null variant of hydra.ext.pegasus.pdl.Schema +schemaNull :: Typed.TypedTerm Pdl.Schema +schemaNull = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "null"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the primitive variant of hydra.ext.pegasus.pdl.Schema +schemaPrimitive :: Typed.TypedTerm Pdl.PrimitiveType -> Typed.TypedTerm Pdl.Schema +schemaPrimitive x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "primitive"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.pegasus.pdl.Schema +schemaSchema :: Typed.TypedName Pdl.Schema +schemaSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Schema") + +-- | DSL injection for the union variant of hydra.ext.pegasus.pdl.Schema +schemaUnion :: Typed.TypedTerm Pdl.UnionSchema -> Typed.TypedTerm Pdl.Schema +schemaUnion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "union"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.EnumFieldName +unEnumFieldName :: Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm String +unEnumFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.FieldName +unFieldName :: Typed.TypedTerm Pdl.FieldName -> Typed.TypedTerm String +unFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.FieldName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Name +unName :: Typed.TypedTerm Pdl.Name -> Typed.TypedTerm String +unName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Name")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Namespace +unNamespace :: Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm String +unNamespace x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Namespace")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Package +unPackage :: Typed.TypedTerm Pdl.Package -> Typed.TypedTerm String +unPackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Package")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.PropertyKey +unPropertyKey :: Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm String +unPropertyKey x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.PropertyKey")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.pegasus.pdl.UnionSchema +unUnionSchema :: Typed.TypedTerm Pdl.UnionSchema -> Typed.TypedTerm [Pdl.UnionMember] +unUnionSchema x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.UnionSchema")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.pegasus.pdl.UnionMember +unionMember :: Typed.TypedTerm (Maybe Pdl.FieldName) -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.UnionMember +unionMember alias value annotations = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm alias)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm annotations)}]})) + +-- | DSL accessor for the alias field of hydra.ext.pegasus.pdl.UnionMember +unionMemberAlias :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm (Maybe Pdl.FieldName) +unionMemberAlias x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.UnionMember +unionMemberAnnotations :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Annotations +unionMemberAnnotations x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.UnionMember +unionMemberUnionMember :: Typed.TypedName Pdl.UnionMember +unionMemberUnionMember = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.UnionMember") + +-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.UnionMember +unionMemberValue :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Schema +unionMemberValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the alias field of hydra.ext.pegasus.pdl.UnionMember +unionMemberWithAlias :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm (Maybe Pdl.FieldName) -> Typed.TypedTerm Pdl.UnionMember +unionMemberWithAlias original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.UnionMember +unionMemberWithAnnotations :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.UnionMember +unionMemberWithAnnotations original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the value field of hydra.ext.pegasus.pdl.UnionMember +unionMemberWithValue :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.UnionMember +unionMemberWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "alias"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "alias")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "annotations"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"), + Model.projectionFieldName = (Model.Name "annotations")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.pegasus.pdl.UnionSchema wrapper +unionSchema :: Typed.TypedTerm [Pdl.UnionMember] -> Typed.TypedTerm Pdl.UnionSchema +unionSchema x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionSchema"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.pegasus.pdl.UnionSchema +unionSchemaUnionSchema :: Typed.TypedName Pdl.UnionSchema +unionSchemaUnionSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.UnionSchema") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Any.hs b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Any.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Any.hs @@ -0,0 +1,82 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.protobuf.any + +module Hydra.Ext.Dsl.Protobuf.Any where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Protobuf.Any as Any +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.ByteString as B + +-- | DSL constructor for hydra.ext.protobuf.any.Any +any :: Typed.TypedTerm String -> Typed.TypedTerm B.ByteString -> Typed.TypedTerm Any.Any +any typeUrl value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeUrl"), + Model.fieldTerm = (Typed.unTypedTerm typeUrl)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL name token for hydra.ext.protobuf.any.Any +anyAny :: Typed.TypedName Any.Any +anyAny = Typed.TypedName (Model.Name "hydra.ext.protobuf.any.Any") + +-- | DSL accessor for the typeUrl field of hydra.ext.protobuf.any.Any +anyTypeUrl :: Typed.TypedTerm Any.Any -> Typed.TypedTerm String +anyTypeUrl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.projectionFieldName = (Model.Name "typeUrl")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the value field of hydra.ext.protobuf.any.Any +anyValue :: Typed.TypedTerm Any.Any -> Typed.TypedTerm B.ByteString +anyValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the typeUrl field of hydra.ext.protobuf.any.Any +anyWithTypeUrl :: Typed.TypedTerm Any.Any -> Typed.TypedTerm String -> Typed.TypedTerm Any.Any +anyWithTypeUrl original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeUrl"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.protobuf.any.Any +anyWithValue :: Typed.TypedTerm Any.Any -> Typed.TypedTerm B.ByteString -> Typed.TypedTerm Any.Any +anyWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "typeUrl"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.any.Any"), + Model.projectionFieldName = (Model.Name "typeUrl")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Environment.hs b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Environment.hs @@ -0,0 +1,104 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.protobuf.environment + +module Hydra.Ext.Dsl.Protobuf.Environment where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Ext.Protobuf.Environment as Environment +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.protobuf.environment.EncoderState +encoderState :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Int -> Typed.TypedTerm Environment.EncoderState +encoderState context fieldIndex = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Typed.unTypedTerm context)}, + Model.Field { + Model.fieldName = (Model.Name "fieldIndex"), + Model.fieldTerm = (Typed.unTypedTerm fieldIndex)}]})) + +-- | DSL accessor for the context field of hydra.ext.protobuf.environment.EncoderState +encoderStateContext :: Typed.TypedTerm Environment.EncoderState -> Typed.TypedTerm Typing.InferenceContext +encoderStateContext x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.environment.EncoderState +encoderStateEncoderState :: Typed.TypedName Environment.EncoderState +encoderStateEncoderState = Typed.TypedName (Model.Name "hydra.ext.protobuf.environment.EncoderState") + +-- | DSL accessor for the fieldIndex field of hydra.ext.protobuf.environment.EncoderState +encoderStateFieldIndex :: Typed.TypedTerm Environment.EncoderState -> Typed.TypedTerm Int +encoderStateFieldIndex x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.projectionFieldName = (Model.Name "fieldIndex")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the context field of hydra.ext.protobuf.environment.EncoderState +encoderStateWithContext :: Typed.TypedTerm Environment.EncoderState -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Environment.EncoderState +encoderStateWithContext original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fieldIndex"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.projectionFieldName = (Model.Name "fieldIndex")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the fieldIndex field of hydra.ext.protobuf.environment.EncoderState +encoderStateWithFieldIndex :: Typed.TypedTerm Environment.EncoderState -> Typed.TypedTerm Int -> Typed.TypedTerm Environment.EncoderState +encoderStateWithFieldIndex original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "context"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.environment.EncoderState"), + Model.projectionFieldName = (Model.Name "context")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fieldIndex"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the either variant of hydra.ext.protobuf.environment.StructuralTypeRef +structuralTypeRefEither :: Typed.TypedTerm (Model.Type, Model.Type) -> Typed.TypedTerm Environment.StructuralTypeRef +structuralTypeRefEither x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.environment.StructuralTypeRef"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "either"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the pair variant of hydra.ext.protobuf.environment.StructuralTypeRef +structuralTypeRefPair :: Typed.TypedTerm (Model.Type, Model.Type) -> Typed.TypedTerm Environment.StructuralTypeRef +structuralTypeRefPair x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.environment.StructuralTypeRef"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "pair"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.protobuf.environment.StructuralTypeRef +structuralTypeRefStructuralTypeRef :: Typed.TypedName Environment.StructuralTypeRef +structuralTypeRefStructuralTypeRef = Typed.TypedName (Model.Name "hydra.ext.protobuf.environment.StructuralTypeRef") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Proto3.hs b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Proto3.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/Proto3.hs @@ -0,0 +1,1304 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.protobuf.proto3 + +module Hydra.Ext.Dsl.Protobuf.Proto3 where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Protobuf.Proto3 as Proto3 +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL name token for hydra.ext.protobuf.proto3.Definition +definitionDefinition :: Typed.TypedName Proto3.Definition +definitionDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Definition") + +-- | DSL injection for the enum variant of hydra.ext.protobuf.proto3.Definition +definitionEnum :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.Definition +definitionEnum x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Definition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enum"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the message variant of hydra.ext.protobuf.proto3.Definition +definitionMessage :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.Definition +definitionMessage x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Definition"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "message"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.protobuf.proto3.EnumDefinition +enumDefinition :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm [Proto3.EnumValue] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumDefinition +enumDefinition name values options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm values)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL name token for hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionEnumDefinition :: Typed.TypedName Proto3.EnumDefinition +enumDefinitionEnumDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition") + +-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionName :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.TypeName +enumDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionOptions :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.Option] +enumDefinitionOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the values field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionValues :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.EnumValue] +enumDefinitionValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionWithName :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.EnumDefinition +enumDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionWithOptions :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumDefinition +enumDefinitionWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the values field of hydra.ext.protobuf.proto3.EnumDefinition +enumDefinitionWithValues :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.EnumValue] -> Typed.TypedTerm Proto3.EnumDefinition +enumDefinitionWithValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.protobuf.proto3.EnumValue +enumValue :: Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm Int -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumValue +enumValue name number options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm number)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL name token for hydra.ext.protobuf.proto3.EnumValue +enumValueEnumValue :: Typed.TypedName Proto3.EnumValue +enumValueEnumValue = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumValue") + +-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.EnumValue +enumValueName :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Proto3.EnumValueName +enumValueName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.protobuf.proto3.EnumValueName wrapper +enumValueName2 :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.EnumValueName +enumValueName2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValueName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.EnumValueName +enumValueNameEnumValueName :: Typed.TypedName Proto3.EnumValueName +enumValueNameEnumValueName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumValueName") + +-- | DSL accessor for the number field of hydra.ext.protobuf.proto3.EnumValue +enumValueNumber :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Int +enumValueNumber x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.EnumValue +enumValueOptions :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm [Proto3.Option] +enumValueOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.protobuf.proto3.EnumValue +enumValueWithName :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm Proto3.EnumValue +enumValueWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the number field of hydra.ext.protobuf.proto3.EnumValue +enumValueWithNumber :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Int -> Typed.TypedTerm Proto3.EnumValue +enumValueWithNumber original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.protobuf.proto3.EnumValue +enumValueWithOptions :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumValue +enumValueWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.protobuf.proto3.Field +field :: Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Proto3.FieldType -> Typed.TypedTerm Int -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.Field +field name jsonName type_ number options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Typed.unTypedTerm jsonName)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm number)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL name token for hydra.ext.protobuf.proto3.Field +fieldField :: Typed.TypedName Proto3.Field +fieldField = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Field") + +-- | DSL accessor for the jsonName field of hydra.ext.protobuf.proto3.Field +fieldJsonName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm (Maybe String) +fieldJsonName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "jsonName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.Field +fieldName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldName +fieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.protobuf.proto3.FieldName wrapper +fieldName2 :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.FieldName +fieldName2 x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.FieldName +fieldNameFieldName :: Typed.TypedName Proto3.FieldName +fieldNameFieldName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FieldName") + +-- | DSL accessor for the number field of hydra.ext.protobuf.proto3.Field +fieldNumber :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Int +fieldNumber x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.Field +fieldOptions :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm [Proto3.Option] +fieldOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.protobuf.proto3.Field +fieldType :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldType +fieldType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.FieldType +fieldTypeFieldType :: Typed.TypedName Proto3.FieldType +fieldTypeFieldType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FieldType") + +-- | DSL injection for the map variant of hydra.ext.protobuf.proto3.FieldType +fieldTypeMap :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.FieldType +fieldTypeMap x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "map"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the oneof variant of hydra.ext.protobuf.proto3.FieldType +fieldTypeOneof :: Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm Proto3.FieldType +fieldTypeOneof x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "oneof"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the repeated variant of hydra.ext.protobuf.proto3.FieldType +fieldTypeRepeated :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.FieldType +fieldTypeRepeated x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "repeated"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the simple variant of hydra.ext.protobuf.proto3.FieldType +fieldTypeSimple :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.FieldType +fieldTypeSimple x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "simple"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the jsonName field of hydra.ext.protobuf.proto3.Field +fieldWithJsonName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Proto3.Field +fieldWithJsonName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.protobuf.proto3.Field +fieldWithName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm Proto3.Field +fieldWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "jsonName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the number field of hydra.ext.protobuf.proto3.Field +fieldWithNumber :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Int -> Typed.TypedTerm Proto3.Field +fieldWithNumber original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "jsonName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.protobuf.proto3.Field +fieldWithOptions :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.Field +fieldWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "jsonName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.protobuf.proto3.Field +fieldWithType :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldType -> Typed.TypedTerm Proto3.Field +fieldWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "jsonName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "jsonName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "number"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "number")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.protobuf.proto3.FileReference wrapper +fileReference :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.FileReference +fileReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.FileReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.FileReference +fileReferenceFileReference :: Typed.TypedName Proto3.FileReference +fileReferenceFileReference = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FileReference") + +-- | DSL constructor for hydra.ext.protobuf.proto3.MapType +mapType :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType +mapType keys values = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keys"), + Model.fieldTerm = (Typed.unTypedTerm keys)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm values)}]})) + +-- | DSL accessor for the keys field of hydra.ext.protobuf.proto3.MapType +mapTypeKeys :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType +mapTypeKeys x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.projectionFieldName = (Model.Name "keys")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.MapType +mapTypeMapType :: Typed.TypedName Proto3.MapType +mapTypeMapType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.MapType") + +-- | DSL accessor for the values field of hydra.ext.protobuf.proto3.MapType +mapTypeValues :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType +mapTypeValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the keys field of hydra.ext.protobuf.proto3.MapType +mapTypeWithKeys :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType +mapTypeWithKeys original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keys"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the values field of hydra.ext.protobuf.proto3.MapType +mapTypeWithValues :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType +mapTypeWithValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "keys"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"), + Model.projectionFieldName = (Model.Name "keys")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.protobuf.proto3.MessageDefinition +messageDefinition :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.MessageDefinition +messageDefinition name fields options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm fields)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL accessor for the fields field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionFields :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Field] +messageDefinitionFields x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionMessageDefinition :: Typed.TypedName Proto3.MessageDefinition +messageDefinitionMessageDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition") + +-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionName :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.TypeName +messageDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionOptions :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Option] +messageDefinitionOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the fields field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionWithFields :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm Proto3.MessageDefinition +messageDefinitionWithFields original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionWithName :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.MessageDefinition +messageDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.protobuf.proto3.MessageDefinition +messageDefinitionWithOptions :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.MessageDefinition +messageDefinitionWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "fields"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"), + Model.projectionFieldName = (Model.Name "fields")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.ext.protobuf.proto3.Option +option :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.Value -> Typed.TypedTerm Proto3.Option +option name value = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm value)}]})) + +-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.Option +optionName :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm String +optionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.Option +optionOption :: Typed.TypedName Proto3.Option +optionOption = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Option") + +-- | DSL accessor for the value field of hydra.ext.protobuf.proto3.Option +optionValue :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm Proto3.Value +optionValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the name field of hydra.ext.protobuf.proto3.Option +optionWithName :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm String -> Typed.TypedTerm Proto3.Option +optionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.projectionFieldName = (Model.Name "value")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the value field of hydra.ext.protobuf.proto3.Option +optionWithValue :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm Proto3.Value -> Typed.TypedTerm Proto3.Option +optionWithValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "value"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.protobuf.proto3.PackageName wrapper +packageName :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.PackageName +packageName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.PackageName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.PackageName +packageNamePackageName :: Typed.TypedName Proto3.PackageName +packageNamePackageName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.PackageName") + +-- | DSL constructor for hydra.ext.protobuf.proto3.ProtoFile +protoFile :: Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm [Proto3.FileReference] -> Typed.TypedTerm [Proto3.Definition] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.ProtoFile +protoFile package imports types options = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm package)}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Typed.unTypedTerm imports)}, + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Typed.unTypedTerm types)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm options)}]})) + +-- | DSL accessor for the imports field of hydra.ext.protobuf.proto3.ProtoFile +protoFileImports :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.FileReference] +protoFileImports x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.ProtoFile +protoFileOptions :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Option] +protoFileOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the package field of hydra.ext.protobuf.proto3.ProtoFile +protoFilePackage :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm Proto3.PackageName +protoFilePackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.ProtoFile +protoFileProtoFile :: Typed.TypedName Proto3.ProtoFile +protoFileProtoFile = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.ProtoFile") + +-- | DSL accessor for the types field of hydra.ext.protobuf.proto3.ProtoFile +protoFileTypes :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Definition] +protoFileTypes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the imports field of hydra.ext.protobuf.proto3.ProtoFile +protoFileWithImports :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.FileReference] -> Typed.TypedTerm Proto3.ProtoFile +protoFileWithImports original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the options field of hydra.ext.protobuf.proto3.ProtoFile +protoFileWithOptions :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.ProtoFile +protoFileWithOptions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the package field of hydra.ext.protobuf.proto3.ProtoFile +protoFileWithPackage :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm Proto3.ProtoFile +protoFileWithPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "types")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the types field of hydra.ext.protobuf.proto3.ProtoFile +protoFileWithTypes :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Definition] -> Typed.TypedTerm Proto3.ProtoFile +protoFileWithTypes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "imports"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "imports")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "types"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "options"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"), + Model.projectionFieldName = (Model.Name "options")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the bool variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeBool :: Typed.TypedTerm Proto3.ScalarType +scalarTypeBool = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bool"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the bytes variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeBytes :: Typed.TypedTerm Proto3.ScalarType +scalarTypeBytes = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bytes"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the double variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeDouble :: Typed.TypedTerm Proto3.ScalarType +scalarTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the fixed32 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeFixed32 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeFixed32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the fixed64 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeFixed64 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeFixed64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "fixed64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeFloat :: Typed.TypedTerm Proto3.ScalarType +scalarTypeFloat = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int32 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeInt32 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeInt32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the int64 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeInt64 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeInt64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.protobuf.proto3.ScalarType +scalarTypeScalarType :: Typed.TypedName Proto3.ScalarType +scalarTypeScalarType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.ScalarType") + +-- | DSL injection for the sfixed32 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeSfixed32 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeSfixed32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sfixed32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sfixed64 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeSfixed64 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeSfixed64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sfixed64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sint32 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeSint32 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeSint32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sint32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the sint64 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeSint64 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeSint64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "sint64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the string variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeString :: Typed.TypedTerm Proto3.ScalarType +scalarTypeString = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uint32 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeUint32 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeUint32 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uint32"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the uint64 variant of hydra.ext.protobuf.proto3.ScalarType +scalarTypeUint64 :: Typed.TypedTerm Proto3.ScalarType +scalarTypeUint64 = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "uint64"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the reference variant of hydra.ext.protobuf.proto3.SimpleType +simpleTypeReference :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.SimpleType +simpleTypeReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.SimpleType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the scalar variant of hydra.ext.protobuf.proto3.SimpleType +simpleTypeScalar :: Typed.TypedTerm Proto3.ScalarType -> Typed.TypedTerm Proto3.SimpleType +simpleTypeScalar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.SimpleType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "scalar"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.protobuf.proto3.SimpleType +simpleTypeSimpleType :: Typed.TypedName Proto3.SimpleType +simpleTypeSimpleType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.SimpleType") + +-- | DSL constructor for the hydra.ext.protobuf.proto3.TypeName wrapper +typeName :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.TypeName +typeName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.TypeName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.TypeName +typeNameTypeName :: Typed.TypedName Proto3.TypeName +typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.TypeName") + +-- | DSL constructor for the hydra.ext.protobuf.proto3.TypeReference wrapper +typeReference :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.TypeReference +typeReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.TypeReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.proto3.TypeReference +typeReferenceTypeReference :: Typed.TypedName Proto3.TypeReference +typeReferenceTypeReference = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.TypeReference") + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.EnumValueName +unEnumValueName :: Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm String +unEnumValueName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.EnumValueName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.FieldName +unFieldName :: Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm String +unFieldName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.FieldName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.FileReference +unFileReference :: Typed.TypedTerm Proto3.FileReference -> Typed.TypedTerm String +unFileReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.FileReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.PackageName +unPackageName :: Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm String +unPackageName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.PackageName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.TypeName +unTypeName :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm String +unTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.TypeName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.protobuf.proto3.TypeReference +unTypeReference :: Typed.TypedTerm Proto3.TypeReference -> Typed.TypedTerm String +unTypeReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.TypeReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the boolean variant of hydra.ext.protobuf.proto3.Value +valueBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Proto3.Value +valueBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.protobuf.proto3.Value +valueString :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.Value +valueString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Value"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.protobuf.proto3.Value +valueValue :: Typed.TypedName Proto3.Value +valueValue = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Value") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Protobuf/SourceContext.hs b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/SourceContext.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Protobuf/SourceContext.hs @@ -0,0 +1,45 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.protobuf.sourceContext + +module Hydra.Ext.Dsl.Protobuf.SourceContext where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Protobuf.SourceContext as SourceContext +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.protobuf.sourceContext.SourceContext +sourceContext :: Typed.TypedTerm String -> Typed.TypedTerm SourceContext.SourceContext +sourceContext fileName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.sourceContext.SourceContext"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fileName"), + Model.fieldTerm = (Typed.unTypedTerm fileName)}]})) + +-- | DSL accessor for the fileName field of hydra.ext.protobuf.sourceContext.SourceContext +sourceContextFileName :: Typed.TypedTerm SourceContext.SourceContext -> Typed.TypedTerm String +sourceContextFileName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.sourceContext.SourceContext"), + Model.projectionFieldName = (Model.Name "fileName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.protobuf.sourceContext.SourceContext +sourceContextSourceContext :: Typed.TypedName SourceContext.SourceContext +sourceContextSourceContext = Typed.TypedName (Model.Name "hydra.ext.protobuf.sourceContext.SourceContext") + +-- | DSL updater for the fileName field of hydra.ext.protobuf.sourceContext.SourceContext +sourceContextWithFileName :: Typed.TypedTerm SourceContext.SourceContext -> Typed.TypedTerm String -> Typed.TypedTerm SourceContext.SourceContext +sourceContextWithFileName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.protobuf.sourceContext.SourceContext"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "fileName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) diff --git a/src/main/haskell/Hydra/Ext/Dsl/Sql/Syntax.hs b/src/main/haskell/Hydra/Ext/Dsl/Sql/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Sql/Syntax.hs @@ -0,0 +1,4858 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.sql.syntax + +module Hydra.Ext.Dsl.Sql.Syntax where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Sql.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for the hydra.ext.sql.syntax.ApproximateNumericLiteral wrapper +approximateNumericLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ApproximateNumericLiteral +approximateNumericLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ApproximateNumericLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ApproximateNumericLiteral +approximateNumericLiteralApproximateNumericLiteral :: Typed.TypedName Syntax.ApproximateNumericLiteral +approximateNumericLiteralApproximateNumericLiteral = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ApproximateNumericLiteral") + +-- | DSL name token for hydra.ext.sql.syntax.ApproximateNumericType +approximateNumericTypeApproximateNumericType :: Typed.TypedName Syntax.ApproximateNumericType +approximateNumericTypeApproximateNumericType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ApproximateNumericType") + +-- | DSL injection for the double variant of hydra.ext.sql.syntax.ApproximateNumericType +approximateNumericTypeDouble :: Typed.TypedTerm Syntax.ApproximateNumericType +approximateNumericTypeDouble = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ApproximateNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "double"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the float variant of hydra.ext.sql.syntax.ApproximateNumericType +approximateNumericTypeFloat :: Typed.TypedTerm (Maybe Syntax.Precision) -> Typed.TypedTerm Syntax.ApproximateNumericType +approximateNumericTypeFloat x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ApproximateNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "float"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the real variant of hydra.ext.sql.syntax.ApproximateNumericType +approximateNumericTypeReal :: Typed.TypedTerm Syntax.ApproximateNumericType +approximateNumericTypeReal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ApproximateNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "real"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ArrayElement wrapper +arrayElement :: Typed.TypedTerm Syntax.ValueExpression -> Typed.TypedTerm Syntax.ArrayElement +arrayElement x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElement"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayElement +arrayElementArrayElement :: Typed.TypedName Syntax.ArrayElement +arrayElementArrayElement = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayElement") + +-- | DSL constructor for hydra.ext.sql.syntax.ArrayElementList +arrayElementList :: Typed.TypedTerm Syntax.ArrayElement -> Typed.TypedTerm [Syntax.ArrayElement] -> Typed.TypedTerm Syntax.ArrayElementList +arrayElementList first rest = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm first)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm rest)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayElementList +arrayElementListArrayElementList :: Typed.TypedName Syntax.ArrayElementList +arrayElementListArrayElementList = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayElementList") + +-- | DSL accessor for the first field of hydra.ext.sql.syntax.ArrayElementList +arrayElementListFirst :: Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm Syntax.ArrayElement +arrayElementListFirst x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rest field of hydra.ext.sql.syntax.ArrayElementList +arrayElementListRest :: Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm [Syntax.ArrayElement] +arrayElementListRest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the first field of hydra.ext.sql.syntax.ArrayElementList +arrayElementListWithFirst :: Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm Syntax.ArrayElement -> Typed.TypedTerm Syntax.ArrayElementList +arrayElementListWithFirst original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rest field of hydra.ext.sql.syntax.ArrayElementList +arrayElementListWithRest :: Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm [Syntax.ArrayElement] -> Typed.TypedTerm Syntax.ArrayElementList +arrayElementListWithRest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ArrayElementReference wrapper +arrayElementReference :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ArrayElementReference +arrayElementReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayElementReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayElementReference +arrayElementReferenceArrayElementReference :: Typed.TypedName Syntax.ArrayElementReference +arrayElementReferenceArrayElementReference = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayElementReference") + +-- | DSL constructor for the hydra.ext.sql.syntax.ArrayType wrapper +arrayType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ArrayType +arrayType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayType +arrayTypeArrayType :: Typed.TypedName Syntax.ArrayType +arrayTypeArrayType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayType") + +-- | DSL name token for hydra.ext.sql.syntax.ArrayValueConstructor +arrayValueConstructorArrayValueConstructor :: Typed.TypedName Syntax.ArrayValueConstructor +arrayValueConstructorArrayValueConstructor = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructor") + +-- | DSL constructor for hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumeration :: Typed.TypedTerm Syntax.LeftBracketOrTrigraph -> Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm Syntax.RightBracketOrTrigraph -> Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumeration leftBracketOrTrigraph arrayElementList rightBracketOrTrigraph = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "LeftBracketOrTrigraph"), + Model.fieldTerm = (Typed.unTypedTerm leftBracketOrTrigraph)}, + Model.Field { + Model.fieldName = (Model.Name "ArrayElementList"), + Model.fieldTerm = (Typed.unTypedTerm arrayElementList)}, + Model.Field { + Model.fieldName = (Model.Name "RightBracketOrTrigraph"), + Model.fieldTerm = (Typed.unTypedTerm rightBracketOrTrigraph)}]})) + +-- | DSL accessor for the ArrayElementList field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationArrayElementList :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.ArrayElementList +arrayValueConstructorByEnumerationArrayElementList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "ArrayElementList")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationArrayValueConstructorByEnumeration :: Typed.TypedName Syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationArrayValueConstructorByEnumeration = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration") + +-- | DSL accessor for the LeftBracketOrTrigraph field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationLeftBracketOrTrigraph :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.LeftBracketOrTrigraph +arrayValueConstructorByEnumerationLeftBracketOrTrigraph x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "LeftBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the RightBracketOrTrigraph field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationRightBracketOrTrigraph :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.RightBracketOrTrigraph +arrayValueConstructorByEnumerationRightBracketOrTrigraph x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "RightBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the ArrayElementList field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithArrayElementList :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.ArrayElementList -> Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithArrayElementList original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "LeftBracketOrTrigraph"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "LeftBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArrayElementList"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "RightBracketOrTrigraph"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "RightBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the LeftBracketOrTrigraph field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithLeftBracketOrTrigraph :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.LeftBracketOrTrigraph -> Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithLeftBracketOrTrigraph original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "LeftBracketOrTrigraph"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ArrayElementList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "ArrayElementList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "RightBracketOrTrigraph"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "RightBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the RightBracketOrTrigraph field of hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithRightBracketOrTrigraph :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.RightBracketOrTrigraph -> Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration +arrayValueConstructorByEnumerationWithRightBracketOrTrigraph original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "LeftBracketOrTrigraph"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "LeftBracketOrTrigraph")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ArrayElementList"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration"), + Model.projectionFieldName = (Model.Name "ArrayElementList")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "RightBracketOrTrigraph"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ArrayValueConstructorByQuery wrapper +arrayValueConstructorByQuery :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ArrayValueConstructorByQuery +arrayValueConstructorByQuery x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByQuery"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayValueConstructorByQuery +arrayValueConstructorByQueryArrayValueConstructorByQuery :: Typed.TypedName Syntax.ArrayValueConstructorByQuery +arrayValueConstructorByQueryArrayValueConstructorByQuery = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByQuery") + +-- | DSL injection for the enumeration variant of hydra.ext.sql.syntax.ArrayValueConstructor +arrayValueConstructorEnumeration :: Typed.TypedTerm Syntax.ArrayValueConstructorByEnumeration -> Typed.TypedTerm Syntax.ArrayValueConstructor +arrayValueConstructorEnumeration x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "enumeration"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the query variant of hydra.ext.sql.syntax.ArrayValueConstructor +arrayValueConstructorQuery :: Typed.TypedTerm Syntax.ArrayValueConstructorByQuery -> Typed.TypedTerm Syntax.ArrayValueConstructor +arrayValueConstructorQuery x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "query"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ArrayValueExpression wrapper +arrayValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ArrayValueExpression +arrayValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ArrayValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ArrayValueExpression +arrayValueExpressionArrayValueExpression :: Typed.TypedName Syntax.ArrayValueExpression +arrayValueExpressionArrayValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ArrayValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.AsSubqueryClause wrapper +asSubqueryClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AsSubqueryClause +asSubqueryClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.AsSubqueryClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.AsSubqueryClause +asSubqueryClauseAsSubqueryClause :: Typed.TypedName Syntax.AsSubqueryClause +asSubqueryClauseAsSubqueryClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.AsSubqueryClause") + +-- | DSL constructor for the hydra.ext.sql.syntax.AttributeOrMethodReference wrapper +attributeOrMethodReference :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AttributeOrMethodReference +attributeOrMethodReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.AttributeOrMethodReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.AttributeOrMethodReference +attributeOrMethodReferenceAttributeOrMethodReference :: Typed.TypedName Syntax.AttributeOrMethodReference +attributeOrMethodReferenceAttributeOrMethodReference = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.AttributeOrMethodReference") + +-- | DSL injection for the binary variant of hydra.ext.sql.syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBinary :: Typed.TypedTerm (Maybe Syntax.LargeObjectLength) -> Typed.TypedTerm Syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BinaryLargeObjectStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBinaryLargeObjectStringType :: Typed.TypedName Syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBinaryLargeObjectStringType = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BinaryLargeObjectStringType") + +-- | DSL injection for the blob variant of hydra.ext.sql.syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBlob :: Typed.TypedTerm (Maybe Syntax.LargeObjectLength) -> Typed.TypedTerm Syntax.BinaryLargeObjectStringType +binaryLargeObjectStringTypeBlob x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BinaryLargeObjectStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "blob"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.BinaryStringLiteral wrapper +binaryStringLiteral :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.BinaryStringLiteral +binaryStringLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.BinaryStringLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.BinaryStringLiteral +binaryStringLiteralBinaryStringLiteral :: Typed.TypedName Syntax.BinaryStringLiteral +binaryStringLiteralBinaryStringLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BinaryStringLiteral") + +-- | DSL constructor for hydra.ext.sql.syntax.BooleanFactor +booleanFactor :: Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm Syntax.BooleanFactor +booleanFactor nOT booleanTest = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Typed.unTypedTerm nOT)}, + Model.Field { + Model.fieldName = (Model.Name "BooleanTest"), + Model.fieldTerm = (Typed.unTypedTerm booleanTest)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanFactor +booleanFactorBooleanFactor :: Typed.TypedName Syntax.BooleanFactor +booleanFactorBooleanFactor = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanFactor") + +-- | DSL accessor for the BooleanTest field of hydra.ext.sql.syntax.BooleanFactor +booleanFactorBooleanTest :: Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm Syntax.BooleanTest +booleanFactorBooleanTest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.projectionFieldName = (Model.Name "BooleanTest")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the NOT field of hydra.ext.sql.syntax.BooleanFactor +booleanFactorNOT :: Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm (Maybe ()) +booleanFactorNOT x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.projectionFieldName = (Model.Name "NOT")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the BooleanTest field of hydra.ext.sql.syntax.BooleanFactor +booleanFactorWithBooleanTest :: Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm Syntax.BooleanFactor +booleanFactorWithBooleanTest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.projectionFieldName = (Model.Name "NOT")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "BooleanTest"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the NOT field of hydra.ext.sql.syntax.BooleanFactor +booleanFactorWithNOT :: Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.BooleanFactor +booleanFactorWithNOT original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "BooleanTest"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanFactor"), + Model.projectionFieldName = (Model.Name "BooleanTest")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanLiteral +booleanLiteralBooleanLiteral :: Typed.TypedName Syntax.BooleanLiteral +booleanLiteralBooleanLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanLiteral") + +-- | DSL injection for the FALSE variant of hydra.ext.sql.syntax.BooleanLiteral +booleanLiteralFALSE :: Typed.TypedTerm Syntax.BooleanLiteral +booleanLiteralFALSE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FALSE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the TRUE variant of hydra.ext.sql.syntax.BooleanLiteral +booleanLiteralTRUE :: Typed.TypedTerm Syntax.BooleanLiteral +booleanLiteralTRUE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "TRUE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the UNKNOWN variant of hydra.ext.sql.syntax.BooleanLiteral +booleanLiteralUNKNOWN :: Typed.TypedTerm Syntax.BooleanLiteral +booleanLiteralUNKNOWN = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "UNKNOWN"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.BooleanPredicand wrapper +booleanPredicand :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.BooleanPredicand +booleanPredicand x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanPredicand"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanPredicand +booleanPredicandBooleanPredicand :: Typed.TypedName Syntax.BooleanPredicand +booleanPredicandBooleanPredicand = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanPredicand") + +-- | DSL name token for hydra.ext.sql.syntax.BooleanPrimary +booleanPrimaryBooleanPrimary :: Typed.TypedName Syntax.BooleanPrimary +booleanPrimaryBooleanPrimary = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanPrimary") + +-- | DSL injection for the predicand variant of hydra.ext.sql.syntax.BooleanPrimary +booleanPrimaryPredicand :: Typed.TypedTerm Syntax.BooleanPredicand -> Typed.TypedTerm Syntax.BooleanPrimary +booleanPrimaryPredicand x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predicand"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the predicate variant of hydra.ext.sql.syntax.BooleanPrimary +booleanPrimaryPredicate :: Typed.TypedTerm Syntax.Predicate -> Typed.TypedTerm Syntax.BooleanPrimary +booleanPrimaryPredicate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predicate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAnd :: Typed.TypedTerm Syntax.BooleanTerm -> Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm Syntax.BooleanTermAnd +booleanTermAnd lhs rhs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Typed.unTypedTerm lhs)}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Typed.unTypedTerm rhs)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAndBooleanTermAnd :: Typed.TypedName Syntax.BooleanTermAnd +booleanTermAndBooleanTermAnd = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd") + +-- | DSL accessor for the lhs field of hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAndLhs :: Typed.TypedTerm Syntax.BooleanTermAnd -> Typed.TypedTerm Syntax.BooleanTerm +booleanTermAndLhs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.projectionFieldName = (Model.Name "lhs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rhs field of hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAndRhs :: Typed.TypedTerm Syntax.BooleanTermAnd -> Typed.TypedTerm Syntax.BooleanFactor +booleanTermAndRhs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.projectionFieldName = (Model.Name "rhs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the lhs field of hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAndWithLhs :: Typed.TypedTerm Syntax.BooleanTermAnd -> Typed.TypedTerm Syntax.BooleanTerm -> Typed.TypedTerm Syntax.BooleanTermAnd +booleanTermAndWithLhs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.projectionFieldName = (Model.Name "rhs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rhs field of hydra.ext.sql.syntax.BooleanTermAnd +booleanTermAndWithRhs :: Typed.TypedTerm Syntax.BooleanTermAnd -> Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm Syntax.BooleanTermAnd +booleanTermAndWithRhs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTermAnd"), + Model.projectionFieldName = (Model.Name "lhs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanTerm +booleanTermBooleanTerm :: Typed.TypedName Syntax.BooleanTerm +booleanTermBooleanTerm = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanTerm") + +-- | DSL injection for the conjunction variant of hydra.ext.sql.syntax.BooleanTerm +booleanTermConjunction :: Typed.TypedTerm Syntax.BooleanTermAnd -> Typed.TypedTerm Syntax.BooleanTerm +booleanTermConjunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTerm"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "conjunction"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the factor variant of hydra.ext.sql.syntax.BooleanTerm +booleanTermFactor :: Typed.TypedTerm Syntax.BooleanFactor -> Typed.TypedTerm Syntax.BooleanTerm +booleanTermFactor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTerm"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "factor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.BooleanTest +booleanTest :: Typed.TypedTerm Syntax.BooleanPrimary -> Typed.TypedTerm (Maybe Syntax.BooleanTestSequenceOption) -> Typed.TypedTerm Syntax.BooleanTest +booleanTest booleanPrimary sequence = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "BooleanPrimary"), + Model.fieldTerm = (Typed.unTypedTerm booleanPrimary)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm sequence)}]})) + +-- | DSL accessor for the BooleanPrimary field of hydra.ext.sql.syntax.BooleanTest +booleanTestBooleanPrimary :: Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm Syntax.BooleanPrimary +booleanTestBooleanPrimary x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.projectionFieldName = (Model.Name "BooleanPrimary")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanTest +booleanTestBooleanTest :: Typed.TypedName Syntax.BooleanTest +booleanTestBooleanTest = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanTest") + +-- | DSL accessor for the Sequence field of hydra.ext.sql.syntax.BooleanTest +booleanTestSequence :: Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm (Maybe Syntax.BooleanTestSequenceOption) +booleanTestSequence x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOption :: Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.TruthValue -> Typed.TypedTerm Syntax.BooleanTestSequenceOption +booleanTestSequenceOption nOT truthValue = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Typed.unTypedTerm nOT)}, + Model.Field { + Model.fieldName = (Model.Name "TruthValue"), + Model.fieldTerm = (Typed.unTypedTerm truthValue)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOptionBooleanTestSequenceOption :: Typed.TypedName Syntax.BooleanTestSequenceOption +booleanTestSequenceOptionBooleanTestSequenceOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption") + +-- | DSL accessor for the NOT field of hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOptionNOT :: Typed.TypedTerm Syntax.BooleanTestSequenceOption -> Typed.TypedTerm (Maybe ()) +booleanTestSequenceOptionNOT x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.projectionFieldName = (Model.Name "NOT")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the TruthValue field of hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOptionTruthValue :: Typed.TypedTerm Syntax.BooleanTestSequenceOption -> Typed.TypedTerm Syntax.TruthValue +booleanTestSequenceOptionTruthValue x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.projectionFieldName = (Model.Name "TruthValue")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the NOT field of hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOptionWithNOT :: Typed.TypedTerm Syntax.BooleanTestSequenceOption -> Typed.TypedTerm (Maybe ()) -> Typed.TypedTerm Syntax.BooleanTestSequenceOption +booleanTestSequenceOptionWithNOT original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "TruthValue"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.projectionFieldName = (Model.Name "TruthValue")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the TruthValue field of hydra.ext.sql.syntax.BooleanTestSequenceOption +booleanTestSequenceOptionWithTruthValue :: Typed.TypedTerm Syntax.BooleanTestSequenceOption -> Typed.TypedTerm Syntax.TruthValue -> Typed.TypedTerm Syntax.BooleanTestSequenceOption +booleanTestSequenceOptionWithTruthValue original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "NOT"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption"), + Model.projectionFieldName = (Model.Name "NOT")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "TruthValue"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the BooleanPrimary field of hydra.ext.sql.syntax.BooleanTest +booleanTestWithBooleanPrimary :: Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm Syntax.BooleanPrimary -> Typed.TypedTerm Syntax.BooleanTest +booleanTestWithBooleanPrimary original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "BooleanPrimary"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Sequence field of hydra.ext.sql.syntax.BooleanTest +booleanTestWithSequence :: Typed.TypedTerm Syntax.BooleanTest -> Typed.TypedTerm (Maybe Syntax.BooleanTestSequenceOption) -> Typed.TypedTerm Syntax.BooleanTest +booleanTestWithSequence original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "BooleanPrimary"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanTest"), + Model.projectionFieldName = (Model.Name "BooleanPrimary")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.BooleanType wrapper +booleanType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.BooleanType +booleanType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanType +booleanTypeBooleanType :: Typed.TypedName Syntax.BooleanType +booleanTypeBooleanType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanType") + +-- | DSL name token for hydra.ext.sql.syntax.BooleanValueExpression +booleanValueExpressionBooleanValueExpression :: Typed.TypedName Syntax.BooleanValueExpression +booleanValueExpressionBooleanValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanValueExpression") + +-- | DSL injection for the disjunction variant of hydra.ext.sql.syntax.BooleanValueExpression +booleanValueExpressionDisjunction :: Typed.TypedTerm Syntax.BooleanValueExpressionOr -> Typed.TypedTerm Syntax.BooleanValueExpression +booleanValueExpressionDisjunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "disjunction"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOr :: Typed.TypedTerm Syntax.BooleanValueExpression -> Typed.TypedTerm Syntax.BooleanTerm -> Typed.TypedTerm Syntax.BooleanValueExpressionOr +booleanValueExpressionOr lhs rhs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Typed.unTypedTerm lhs)}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Typed.unTypedTerm rhs)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOrBooleanValueExpressionOr :: Typed.TypedName Syntax.BooleanValueExpressionOr +booleanValueExpressionOrBooleanValueExpressionOr = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr") + +-- | DSL accessor for the lhs field of hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOrLhs :: Typed.TypedTerm Syntax.BooleanValueExpressionOr -> Typed.TypedTerm Syntax.BooleanValueExpression +booleanValueExpressionOrLhs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.projectionFieldName = (Model.Name "lhs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rhs field of hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOrRhs :: Typed.TypedTerm Syntax.BooleanValueExpressionOr -> Typed.TypedTerm Syntax.BooleanTerm +booleanValueExpressionOrRhs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.projectionFieldName = (Model.Name "rhs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the lhs field of hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOrWithLhs :: Typed.TypedTerm Syntax.BooleanValueExpressionOr -> Typed.TypedTerm Syntax.BooleanValueExpression -> Typed.TypedTerm Syntax.BooleanValueExpressionOr +booleanValueExpressionOrWithLhs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.projectionFieldName = (Model.Name "rhs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rhs field of hydra.ext.sql.syntax.BooleanValueExpressionOr +booleanValueExpressionOrWithRhs :: Typed.TypedTerm Syntax.BooleanValueExpressionOr -> Typed.TypedTerm Syntax.BooleanTerm -> Typed.TypedTerm Syntax.BooleanValueExpressionOr +booleanValueExpressionOrWithRhs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "lhs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr"), + Model.projectionFieldName = (Model.Name "lhs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rhs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the term variant of hydra.ext.sql.syntax.BooleanValueExpression +booleanValueExpressionTerm :: Typed.TypedTerm Syntax.BooleanTerm -> Typed.TypedTerm Syntax.BooleanValueExpression +booleanValueExpressionTerm x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.BooleanValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.CaseExpression wrapper +caseExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.CaseExpression +caseExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.CaseExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.CaseExpression +caseExpressionCaseExpression :: Typed.TypedName Syntax.CaseExpression +caseExpressionCaseExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CaseExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.CastSpecification wrapper +castSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.CastSpecification +castSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.CastSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.CastSpecification +castSpecificationCastSpecification :: Typed.TypedName Syntax.CastSpecification +castSpecificationCastSpecification = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CastSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.CharacterSetSpecification wrapper +characterSetSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.CharacterSetSpecification +characterSetSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterSetSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.CharacterSetSpecification +characterSetSpecificationCharacterSetSpecification :: Typed.TypedName Syntax.CharacterSetSpecification +characterSetSpecificationCharacterSetSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CharacterSetSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.CharacterStringLiteral wrapper +characterStringLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.CharacterStringLiteral +characterStringLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.CharacterStringLiteral +characterStringLiteralCharacterStringLiteral :: Typed.TypedName Syntax.CharacterStringLiteral +characterStringLiteralCharacterStringLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CharacterStringLiteral") + +-- | DSL injection for the char variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeChar :: Typed.TypedTerm (Maybe Syntax.Length) -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeChar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "char"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the charLargeObject variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharLargeObject :: Typed.TypedTerm (Maybe Syntax.LargeObjectLength) -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeCharLargeObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "charLargeObject"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the charVarying variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharVarying :: Typed.TypedTerm Syntax.Length -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeCharVarying x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "charVarying"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the character variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharacter :: Typed.TypedTerm (Maybe Syntax.Length) -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeCharacter x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "character"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the characterLargeObject variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharacterLargeObject :: Typed.TypedTerm (Maybe Syntax.LargeObjectLength) -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeCharacterLargeObject x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "characterLargeObject"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharacterStringType :: Typed.TypedName Syntax.CharacterStringType +characterStringTypeCharacterStringType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CharacterStringType") + +-- | DSL injection for the characterVarying variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeCharacterVarying :: Typed.TypedTerm Syntax.Length -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeCharacterVarying x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "characterVarying"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the clob variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeClob :: Typed.TypedTerm (Maybe Syntax.LargeObjectLength) -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeClob x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "clob"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the varchar variant of hydra.ext.sql.syntax.CharacterStringType +characterStringTypeVarchar :: Typed.TypedTerm Syntax.Length -> Typed.TypedTerm Syntax.CharacterStringType +characterStringTypeVarchar x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CharacterStringType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "varchar"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.CollateClause wrapper +collateClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.CollateClause +collateClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.CollateClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.CollateClause +collateClauseCollateClause :: Typed.TypedName Syntax.CollateClause +collateClauseCollateClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CollateClause") + +-- | DSL injection for the array variant of hydra.ext.sql.syntax.CollectionType +collectionTypeArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.CollectionType +collectionTypeArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.CollectionType +collectionTypeCollectionType :: Typed.TypedName Syntax.CollectionType +collectionTypeCollectionType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CollectionType") + +-- | DSL injection for the multiset variant of hydra.ext.sql.syntax.CollectionType +collectionTypeMultiset :: Typed.TypedTerm Syntax.MultisetType -> Typed.TypedTerm Syntax.CollectionType +collectionTypeMultiset x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiset"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the array variant of hydra.ext.sql.syntax.CollectionValueConstructor +collectionValueConstructorArray :: Typed.TypedTerm Syntax.ArrayValueConstructor -> Typed.TypedTerm Syntax.CollectionValueConstructor +collectionValueConstructorArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionValueConstructor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.CollectionValueConstructor +collectionValueConstructorCollectionValueConstructor :: Typed.TypedName Syntax.CollectionValueConstructor +collectionValueConstructorCollectionValueConstructor = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CollectionValueConstructor") + +-- | DSL injection for the multiset variant of hydra.ext.sql.syntax.CollectionValueConstructor +collectionValueConstructorMultiset :: Typed.TypedTerm Syntax.MultisetValueConstructor -> Typed.TypedTerm Syntax.CollectionValueConstructor +collectionValueConstructorMultiset x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionValueConstructor"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiset"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the array variant of hydra.ext.sql.syntax.CollectionValueExpression +collectionValueExpressionArray :: Typed.TypedTerm Syntax.ArrayValueExpression -> Typed.TypedTerm Syntax.CollectionValueExpression +collectionValueExpressionArray x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "array"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.CollectionValueExpression +collectionValueExpressionCollectionValueExpression :: Typed.TypedName Syntax.CollectionValueExpression +collectionValueExpressionCollectionValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CollectionValueExpression") + +-- | DSL injection for the multiset variant of hydra.ext.sql.syntax.CollectionValueExpression +collectionValueExpressionMultiset :: Typed.TypedTerm Syntax.MultisetValueExpression -> Typed.TypedTerm Syntax.CollectionValueExpression +collectionValueExpressionMultiset x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CollectionValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multiset"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ColumnConstraintDefinition wrapper +columnConstraintDefinition :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ColumnConstraintDefinition +columnConstraintDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnConstraintDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnConstraintDefinition +columnConstraintDefinitionColumnConstraintDefinition :: Typed.TypedName Syntax.ColumnConstraintDefinition +columnConstraintDefinitionColumnConstraintDefinition = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnConstraintDefinition") + +-- | DSL constructor for hydra.ext.sql.syntax.ColumnDefinition +columnDefinition :: Typed.TypedTerm Syntax.ColumnName -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionTypeOrDomainOption) -> Typed.TypedTerm (Maybe Syntax.ReferenceScopeCheck) -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption) -> Typed.TypedTerm [Syntax.ColumnConstraintDefinition] -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinition name typeOrDomain refScope defaultOrIdentityOrGeneration constraints collate = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Typed.unTypedTerm typeOrDomain)}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Typed.unTypedTerm refScope)}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Typed.unTypedTerm defaultOrIdentityOrGeneration)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm constraints)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm collate)}]})) + +-- | DSL accessor for the collate field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionCollate :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.CollateClause) +columnDefinitionCollate x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionColumnDefinition :: Typed.TypedName Syntax.ColumnDefinition +columnDefinitionColumnDefinition = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnDefinition") + +-- | DSL accessor for the constraints field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionConstraints :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm [Syntax.ColumnConstraintDefinition] +columnDefinitionConstraints x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the defaultOrIdentityOrGeneration field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionDefaultOrIdentityOrGeneration :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption) +columnDefinitionDefaultOrIdentityOrGeneration x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionColumnDefinitionDefaultOrIdentityOrGenerationOption :: Typed.TypedName Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionColumnDefinitionDefaultOrIdentityOrGenerationOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption") + +-- | DSL injection for the DefaultClause variant of hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionDefaultClause :: Typed.TypedTerm Syntax.DefaultClause -> Typed.TypedTerm Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionDefaultClause x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "DefaultClause"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the GenerationClause variant of hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionGenerationClause :: Typed.TypedTerm Syntax.GenerationClause -> Typed.TypedTerm Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionGenerationClause x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "GenerationClause"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the IdentityColumnSpecification variant of hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionIdentityColumnSpecification :: Typed.TypedTerm Syntax.IdentityColumnSpecification -> Typed.TypedTerm Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption +columnDefinitionDefaultOrIdentityOrGenerationOptionIdentityColumnSpecification x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "IdentityColumnSpecification"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the name field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionName :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm Syntax.ColumnName +columnDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the refScope field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionRefScope :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ReferenceScopeCheck) +columnDefinitionRefScope x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeOrDomain field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionTypeOrDomain :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionTypeOrDomainOption) +columnDefinitionTypeOrDomain x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionColumnDefinitionTypeOrDomainOption :: Typed.TypedName Syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionColumnDefinitionTypeOrDomainOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption") + +-- | DSL injection for the DataType variant of hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionDataType :: Typed.TypedTerm Syntax.DataType -> Typed.TypedTerm Syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionDataType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "DataType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the DomainName variant of hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionDomainName :: Typed.TypedTerm Syntax.DomainName -> Typed.TypedTerm Syntax.ColumnDefinitionTypeOrDomainOption +columnDefinitionTypeOrDomainOptionDomainName x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "DomainName"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL updater for the collate field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithCollate :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithCollate original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the constraints field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithConstraints :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm [Syntax.ColumnConstraintDefinition] -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithConstraints original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the defaultOrIdentityOrGeneration field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithDefaultOrIdentityOrGeneration :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption) -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithDefaultOrIdentityOrGeneration original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithName :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm Syntax.ColumnName -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the refScope field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithRefScope :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ReferenceScopeCheck) -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithRefScope original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "typeOrDomain")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeOrDomain field of hydra.ext.sql.syntax.ColumnDefinition +columnDefinitionWithTypeOrDomain :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm (Maybe Syntax.ColumnDefinitionTypeOrDomainOption) -> Typed.TypedTerm Syntax.ColumnDefinition +columnDefinitionWithTypeOrDomain original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeOrDomain"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "refScope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "refScope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "defaultOrIdentityOrGeneration"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "defaultOrIdentityOrGeneration")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "constraints"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "constraints")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnDefinition"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ColumnName wrapper +columnName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ColumnName +columnName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnName +columnNameColumnName :: Typed.TypedName Syntax.ColumnName +columnNameColumnName = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnName") + +-- | DSL constructor for hydra.ext.sql.syntax.ColumnNameList +columnNameList :: Typed.TypedTerm Syntax.ColumnName -> Typed.TypedTerm [Syntax.ColumnName] -> Typed.TypedTerm Syntax.ColumnNameList +columnNameList first rest = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm first)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm rest)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnNameList +columnNameListColumnNameList :: Typed.TypedName Syntax.ColumnNameList +columnNameListColumnNameList = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnNameList") + +-- | DSL accessor for the first field of hydra.ext.sql.syntax.ColumnNameList +columnNameListFirst :: Typed.TypedTerm Syntax.ColumnNameList -> Typed.TypedTerm Syntax.ColumnName +columnNameListFirst x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rest field of hydra.ext.sql.syntax.ColumnNameList +columnNameListRest :: Typed.TypedTerm Syntax.ColumnNameList -> Typed.TypedTerm [Syntax.ColumnName] +columnNameListRest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the first field of hydra.ext.sql.syntax.ColumnNameList +columnNameListWithFirst :: Typed.TypedTerm Syntax.ColumnNameList -> Typed.TypedTerm Syntax.ColumnName -> Typed.TypedTerm Syntax.ColumnNameList +columnNameListWithFirst original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rest field of hydra.ext.sql.syntax.ColumnNameList +columnNameListWithRest :: Typed.TypedTerm Syntax.ColumnNameList -> Typed.TypedTerm [Syntax.ColumnName] -> Typed.TypedTerm Syntax.ColumnNameList +columnNameListWithRest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnNameList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ColumnOptions wrapper +columnOptions :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ColumnOptions +columnOptions x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnOptions"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnOptions +columnOptionsColumnOptions :: Typed.TypedName Syntax.ColumnOptions +columnOptionsColumnOptions = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnOptions") + +-- | DSL constructor for the hydra.ext.sql.syntax.ColumnReference wrapper +columnReference :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ColumnReference +columnReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ColumnReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ColumnReference +columnReferenceColumnReference :: Typed.TypedName Syntax.ColumnReference +columnReferenceColumnReference = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ColumnReference") + +-- | DSL injection for the collection variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionCollection :: Typed.TypedTerm Syntax.CollectionValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionCommonValueExpression :: Typed.TypedName Syntax.CommonValueExpression +commonValueExpressionCommonValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.CommonValueExpression") + +-- | DSL injection for the datetime variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionDatetime :: Typed.TypedTerm Syntax.DatetimeValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionDatetime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "datetime"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interval variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionInterval :: Typed.TypedTerm Syntax.IntervalValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionInterval x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interval"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the numeric variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionNumeric :: Typed.TypedTerm Syntax.NumericValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionNumeric x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "numeric"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the reference variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionReference :: Typed.TypedTerm Syntax.ReferenceValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionString :: Typed.TypedTerm Syntax.StringValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the userDefined variant of hydra.ext.sql.syntax.CommonValueExpression +commonValueExpressionUserDefined :: Typed.TypedTerm Syntax.UserDefinedTypeValueExpression -> Typed.TypedTerm Syntax.CommonValueExpression +commonValueExpressionUserDefined x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.CommonValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "userDefined"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor wrapper +contextuallyTypedRowValueConstructor :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueConstructor +contextuallyTypedRowValueConstructor x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor +contextuallyTypedRowValueConstructorContextuallyTypedRowValueConstructor :: Typed.TypedName Syntax.ContextuallyTypedRowValueConstructor +contextuallyTypedRowValueConstructorContextuallyTypedRowValueConstructor = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor") + +-- | DSL injection for the constructor variant of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionConstructor :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueConstructor -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionContextuallyTypedRowValueExpression :: Typed.TypedName Syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionContextuallyTypedRowValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression") + +-- | DSL constructor for hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionList :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpression -> Typed.TypedTerm [Syntax.ContextuallyTypedRowValueExpression] -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionList first rest = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm first)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm rest)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListContextuallyTypedRowValueExpressionList :: Typed.TypedName Syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListContextuallyTypedRowValueExpressionList = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList") + +-- | DSL accessor for the first field of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListFirst :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionListFirst x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rest field of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListRest :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList -> Typed.TypedTerm [Syntax.ContextuallyTypedRowValueExpression] +contextuallyTypedRowValueExpressionListRest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the first field of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListWithFirst :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpression -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListWithFirst original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rest field of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListWithRest :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList -> Typed.TypedTerm [Syntax.ContextuallyTypedRowValueExpression] -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList +contextuallyTypedRowValueExpressionListWithRest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the specialCase variant of hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionSpecialCase :: Typed.TypedTerm Syntax.RowValueSpecialCase -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpression +contextuallyTypedRowValueExpressionSpecialCase x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "specialCase"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor wrapper +contextuallyTypedTableValueConstructor :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList -> Typed.TypedTerm Syntax.ContextuallyTypedTableValueConstructor +contextuallyTypedTableValueConstructor x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor +contextuallyTypedTableValueConstructorContextuallyTypedTableValueConstructor :: Typed.TypedName Syntax.ContextuallyTypedTableValueConstructor +contextuallyTypedTableValueConstructorContextuallyTypedTableValueConstructor = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor") + +-- | DSL injection for the collection variant of hydra.ext.sql.syntax.DataType +dataTypeCollection :: Typed.TypedTerm Syntax.CollectionType -> Typed.TypedTerm Syntax.DataType +dataTypeCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.DataType +dataTypeDataType :: Typed.TypedName Syntax.DataType +dataTypeDataType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DataType") + +-- | DSL injection for the named variant of hydra.ext.sql.syntax.DataType +dataTypeNamed :: Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName -> Typed.TypedTerm Syntax.DataType +dataTypeNamed x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "named"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the predefined variant of hydra.ext.sql.syntax.DataType +dataTypePredefined :: Typed.TypedTerm Syntax.PredefinedType -> Typed.TypedTerm Syntax.DataType +dataTypePredefined x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "predefined"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the reference variant of hydra.ext.sql.syntax.DataType +dataTypeReference :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.DataType +dataTypeReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the row variant of hydra.ext.sql.syntax.DataType +dataTypeRow :: Typed.TypedTerm Syntax.RowType -> Typed.TypedTerm Syntax.DataType +dataTypeRow x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DataType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "row"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.DateLiteral wrapper +dateLiteral :: Typed.TypedTerm Syntax.DateString -> Typed.TypedTerm Syntax.DateLiteral +dateLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DateLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DateLiteral +dateLiteralDateLiteral :: Typed.TypedName Syntax.DateLiteral +dateLiteralDateLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DateLiteral") + +-- | DSL constructor for the hydra.ext.sql.syntax.DateString wrapper +dateString :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.DateString +dateString x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DateString"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DateString +dateStringDateString :: Typed.TypedName Syntax.DateString +dateStringDateString = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DateString") + +-- | DSL injection for the date variant of hydra.ext.sql.syntax.DatetimeLiteral +datetimeLiteralDate :: Typed.TypedTerm Syntax.DateLiteral -> Typed.TypedTerm Syntax.DatetimeLiteral +datetimeLiteralDate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DatetimeLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "date"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.DatetimeLiteral +datetimeLiteralDatetimeLiteral :: Typed.TypedName Syntax.DatetimeLiteral +datetimeLiteralDatetimeLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DatetimeLiteral") + +-- | DSL injection for the time variant of hydra.ext.sql.syntax.DatetimeLiteral +datetimeLiteralTime :: Typed.TypedTerm Syntax.TimeLiteral -> Typed.TypedTerm Syntax.DatetimeLiteral +datetimeLiteralTime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DatetimeLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "time"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the timestamp variant of hydra.ext.sql.syntax.DatetimeLiteral +datetimeLiteralTimestamp :: Typed.TypedTerm Syntax.TimestampLiteral -> Typed.TypedTerm Syntax.DatetimeLiteral +datetimeLiteralTimestamp x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.DatetimeLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.DatetimeType wrapper +datetimeType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.DatetimeType +datetimeType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DatetimeType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DatetimeType +datetimeTypeDatetimeType :: Typed.TypedName Syntax.DatetimeType +datetimeTypeDatetimeType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DatetimeType") + +-- | DSL constructor for the hydra.ext.sql.syntax.DatetimeValueExpression wrapper +datetimeValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.DatetimeValueExpression +datetimeValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DatetimeValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DatetimeValueExpression +datetimeValueExpressionDatetimeValueExpression :: Typed.TypedName Syntax.DatetimeValueExpression +datetimeValueExpressionDatetimeValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DatetimeValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.DefaultClause wrapper +defaultClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.DefaultClause +defaultClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DefaultClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DefaultClause +defaultClauseDefaultClause :: Typed.TypedName Syntax.DefaultClause +defaultClauseDefaultClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DefaultClause") + +-- | DSL constructor for the hydra.ext.sql.syntax.DomainName wrapper +domainName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.DomainName +domainName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.DomainName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.DomainName +domainNameDomainName :: Typed.TypedName Syntax.DomainName +domainNameDomainName = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.DomainName") + +-- | DSL constructor for the hydra.ext.sql.syntax.ExactNumericLiteral wrapper +exactNumericLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ExactNumericLiteral +exactNumericLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ExactNumericLiteral +exactNumericLiteralExactNumericLiteral :: Typed.TypedName Syntax.ExactNumericLiteral +exactNumericLiteralExactNumericLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ExactNumericLiteral") + +-- | DSL injection for the bigint variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeBigint :: Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeBigint = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "bigint"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the dec variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeDec :: Typed.TypedTerm (Maybe Syntax.ExactNumericTypeDecOption) -> Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeDec x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dec"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOption :: Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeDecOption +exactNumericTypeDecOption precision sequence = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm precision)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm sequence)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionExactNumericTypeDecOption :: Typed.TypedName Syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionExactNumericTypeDecOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption") + +-- | DSL accessor for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeDecOption -> Typed.TypedTerm Syntax.Precision +exactNumericTypeDecOptionPrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionSequence :: Typed.TypedTerm Syntax.ExactNumericTypeDecOption -> Typed.TypedTerm (Maybe Syntax.Scale) +exactNumericTypeDecOptionSequence x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionWithPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeDecOption -> Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm Syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionWithPrecision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionWithSequence :: Typed.TypedTerm Syntax.ExactNumericTypeDecOption -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeDecOption +exactNumericTypeDecOptionWithSequence original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the decimal variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeDecimal :: Typed.TypedTerm (Maybe Syntax.ExactNumericTypeDecimalOption) -> Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeDecimal x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "decimal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOption :: Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOption precision sequence = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm precision)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm sequence)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionExactNumericTypeDecimalOption :: Typed.TypedName Syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionExactNumericTypeDecimalOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption") + +-- | DSL accessor for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption -> Typed.TypedTerm Syntax.Precision +exactNumericTypeDecimalOptionPrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionSequence :: Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption -> Typed.TypedTerm (Maybe Syntax.Scale) +exactNumericTypeDecimalOptionSequence x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionWithPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption -> Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionWithPrecision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionWithSequence :: Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeDecimalOption +exactNumericTypeDecimalOptionWithSequence original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeExactNumericType :: Typed.TypedName Syntax.ExactNumericType +exactNumericTypeExactNumericType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ExactNumericType") + +-- | DSL injection for the int variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeInt :: Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeInt = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "int"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the integer variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeInteger :: Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeInteger = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "integer"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the numeric variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeNumeric :: Typed.TypedTerm (Maybe Syntax.ExactNumericTypeNumericOption) -> Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeNumeric x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "numeric"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOption :: Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOption precision sequence = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm precision)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm sequence)}]})) + +-- | DSL name token for hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionExactNumericTypeNumericOption :: Typed.TypedName Syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionExactNumericTypeNumericOption = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption") + +-- | DSL accessor for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeNumericOption -> Typed.TypedTerm Syntax.Precision +exactNumericTypeNumericOptionPrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionSequence :: Typed.TypedTerm Syntax.ExactNumericTypeNumericOption -> Typed.TypedTerm (Maybe Syntax.Scale) +exactNumericTypeNumericOptionSequence x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the Precision field of hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionWithPrecision :: Typed.TypedTerm Syntax.ExactNumericTypeNumericOption -> Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm Syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionWithPrecision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.projectionFieldName = (Model.Name "Sequence")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the Sequence field of hydra.ext.sql.syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionWithSequence :: Typed.TypedTerm Syntax.ExactNumericTypeNumericOption -> Typed.TypedTerm (Maybe Syntax.Scale) -> Typed.TypedTerm Syntax.ExactNumericTypeNumericOption +exactNumericTypeNumericOptionWithSequence original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "Precision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption"), + Model.projectionFieldName = (Model.Name "Precision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "Sequence"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the smallint variant of hydra.ext.sql.syntax.ExactNumericType +exactNumericTypeSmallint :: Typed.TypedTerm Syntax.ExactNumericType +exactNumericTypeSmallint = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ExactNumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "smallint"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.FieldReference wrapper +fieldReference :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.FieldReference +fieldReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.FieldReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.FieldReference +fieldReferenceFieldReference :: Typed.TypedName Syntax.FieldReference +fieldReferenceFieldReference = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.FieldReference") + +-- | DSL constructor for hydra.ext.sql.syntax.FromConstructor +fromConstructor :: Typed.TypedTerm (Maybe Syntax.InsertColumnList) -> Typed.TypedTerm (Maybe Syntax.OverrideClause) -> Typed.TypedTerm Syntax.ContextuallyTypedTableValueConstructor -> Typed.TypedTerm Syntax.FromConstructor +fromConstructor columns override values = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm columns)}, + Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = (Typed.unTypedTerm override)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm values)}]})) + +-- | DSL accessor for the columns field of hydra.ext.sql.syntax.FromConstructor +fromConstructorColumns :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm (Maybe Syntax.InsertColumnList) +fromConstructorColumns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.FromConstructor +fromConstructorFromConstructor :: Typed.TypedName Syntax.FromConstructor +fromConstructorFromConstructor = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.FromConstructor") + +-- | DSL accessor for the override field of hydra.ext.sql.syntax.FromConstructor +fromConstructorOverride :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm (Maybe Syntax.OverrideClause) +fromConstructorOverride x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "override")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the values field of hydra.ext.sql.syntax.FromConstructor +fromConstructorValues :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm Syntax.ContextuallyTypedTableValueConstructor +fromConstructorValues x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the columns field of hydra.ext.sql.syntax.FromConstructor +fromConstructorWithColumns :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm (Maybe Syntax.InsertColumnList) -> Typed.TypedTerm Syntax.FromConstructor +fromConstructorWithColumns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "override")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the override field of hydra.ext.sql.syntax.FromConstructor +fromConstructorWithOverride :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm (Maybe Syntax.OverrideClause) -> Typed.TypedTerm Syntax.FromConstructor +fromConstructorWithOverride original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "values")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the values field of hydra.ext.sql.syntax.FromConstructor +fromConstructorWithValues :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm Syntax.ContextuallyTypedTableValueConstructor -> Typed.TypedTerm Syntax.FromConstructor +fromConstructorWithValues original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "columns"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "columns")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "override"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.FromConstructor"), + Model.projectionFieldName = (Model.Name "override")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "values"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.FromDefault wrapper +fromDefault :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.FromDefault +fromDefault x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.FromDefault"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.FromDefault +fromDefaultFromDefault :: Typed.TypedName Syntax.FromDefault +fromDefaultFromDefault = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.FromDefault") + +-- | DSL constructor for the hydra.ext.sql.syntax.FromSubquery wrapper +fromSubquery :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.FromSubquery +fromSubquery x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.FromSubquery"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.FromSubquery +fromSubqueryFromSubquery :: Typed.TypedName Syntax.FromSubquery +fromSubqueryFromSubquery = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.FromSubquery") + +-- | DSL injection for the binary variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralBinary :: Typed.TypedTerm Syntax.BinaryStringLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralBinary x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "binary"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the boolean variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralBoolean :: Typed.TypedTerm Syntax.BooleanLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the dateTime variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralDateTime :: Typed.TypedTerm Syntax.DatetimeLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralDateTime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dateTime"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.GeneralLiteral +generalLiteralGeneralLiteral :: Typed.TypedName Syntax.GeneralLiteral +generalLiteralGeneralLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.GeneralLiteral") + +-- | DSL injection for the interval variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralInterval :: Typed.TypedTerm Syntax.IntervalLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralInterval x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interval"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the nationalString variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralNationalString :: Typed.TypedTerm Syntax.NationalCharacterStringLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralNationalString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nationalString"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the string variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralString :: Typed.TypedTerm Syntax.CharacterStringLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralString x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "string"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unicode variant of hydra.ext.sql.syntax.GeneralLiteral +generalLiteralUnicode :: Typed.TypedTerm Syntax.UnicodeCharacterStringLiteral -> Typed.TypedTerm Syntax.GeneralLiteral +generalLiteralUnicode x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unicode"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.GeneralValueSpecification wrapper +generalValueSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.GeneralValueSpecification +generalValueSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.GeneralValueSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.GeneralValueSpecification +generalValueSpecificationGeneralValueSpecification :: Typed.TypedName Syntax.GeneralValueSpecification +generalValueSpecificationGeneralValueSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.GeneralValueSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.GenerationClause wrapper +generationClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.GenerationClause +generationClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.GenerationClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.GenerationClause +generationClauseGenerationClause :: Typed.TypedName Syntax.GenerationClause +generationClauseGenerationClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.GenerationClause") + +-- | DSL injection for the global variant of hydra.ext.sql.syntax.GlobalOrLocal +globalOrLocalGlobal :: Typed.TypedTerm Syntax.GlobalOrLocal +globalOrLocalGlobal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GlobalOrLocal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "global"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.sql.syntax.GlobalOrLocal +globalOrLocalGlobalOrLocal :: Typed.TypedName Syntax.GlobalOrLocal +globalOrLocalGlobalOrLocal = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.GlobalOrLocal") + +-- | DSL injection for the local variant of hydra.ext.sql.syntax.GlobalOrLocal +globalOrLocalLocal :: Typed.TypedTerm Syntax.GlobalOrLocal +globalOrLocalLocal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.GlobalOrLocal"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "local"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.ext.sql.syntax.IdentityColumnSpecification wrapper +identityColumnSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.IdentityColumnSpecification +identityColumnSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.IdentityColumnSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.IdentityColumnSpecification +identityColumnSpecificationIdentityColumnSpecification :: Typed.TypedName Syntax.IdentityColumnSpecification +identityColumnSpecificationIdentityColumnSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.IdentityColumnSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.InsertColumnList wrapper +insertColumnList :: Typed.TypedTerm Syntax.ColumnNameList -> Typed.TypedTerm Syntax.InsertColumnList +insertColumnList x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.InsertColumnList"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.InsertColumnList +insertColumnListInsertColumnList :: Typed.TypedName Syntax.InsertColumnList +insertColumnListInsertColumnList = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.InsertColumnList") + +-- | DSL injection for the constructor variant of hydra.ext.sql.syntax.InsertColumnsAndSource +insertColumnsAndSourceConstructor :: Typed.TypedTerm Syntax.FromConstructor -> Typed.TypedTerm Syntax.InsertColumnsAndSource +insertColumnsAndSourceConstructor x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertColumnsAndSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "constructor"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the default variant of hydra.ext.sql.syntax.InsertColumnsAndSource +insertColumnsAndSourceDefault :: Typed.TypedTerm Syntax.FromDefault -> Typed.TypedTerm Syntax.InsertColumnsAndSource +insertColumnsAndSourceDefault x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertColumnsAndSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "default"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.InsertColumnsAndSource +insertColumnsAndSourceInsertColumnsAndSource :: Typed.TypedName Syntax.InsertColumnsAndSource +insertColumnsAndSourceInsertColumnsAndSource = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.InsertColumnsAndSource") + +-- | DSL injection for the subquery variant of hydra.ext.sql.syntax.InsertColumnsAndSource +insertColumnsAndSourceSubquery :: Typed.TypedTerm Syntax.FromSubquery -> Typed.TypedTerm Syntax.InsertColumnsAndSource +insertColumnsAndSourceSubquery x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertColumnsAndSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subquery"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.InsertStatement +insertStatement :: Typed.TypedTerm Syntax.InsertionTarget -> Typed.TypedTerm Syntax.InsertColumnsAndSource -> Typed.TypedTerm Syntax.InsertStatement +insertStatement target columnsAndSource = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "columnsAndSource"), + Model.fieldTerm = (Typed.unTypedTerm columnsAndSource)}]})) + +-- | DSL accessor for the columnsAndSource field of hydra.ext.sql.syntax.InsertStatement +insertStatementColumnsAndSource :: Typed.TypedTerm Syntax.InsertStatement -> Typed.TypedTerm Syntax.InsertColumnsAndSource +insertStatementColumnsAndSource x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.projectionFieldName = (Model.Name "columnsAndSource")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.InsertStatement +insertStatementInsertStatement :: Typed.TypedName Syntax.InsertStatement +insertStatementInsertStatement = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.InsertStatement") + +-- | DSL accessor for the target field of hydra.ext.sql.syntax.InsertStatement +insertStatementTarget :: Typed.TypedTerm Syntax.InsertStatement -> Typed.TypedTerm Syntax.InsertionTarget +insertStatementTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the columnsAndSource field of hydra.ext.sql.syntax.InsertStatement +insertStatementWithColumnsAndSource :: Typed.TypedTerm Syntax.InsertStatement -> Typed.TypedTerm Syntax.InsertColumnsAndSource -> Typed.TypedTerm Syntax.InsertStatement +insertStatementWithColumnsAndSource original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "columnsAndSource"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the target field of hydra.ext.sql.syntax.InsertStatement +insertStatementWithTarget :: Typed.TypedTerm Syntax.InsertStatement -> Typed.TypedTerm Syntax.InsertionTarget -> Typed.TypedTerm Syntax.InsertStatement +insertStatementWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "columnsAndSource"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.InsertStatement"), + Model.projectionFieldName = (Model.Name "columnsAndSource")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.InsertionTarget wrapper +insertionTarget :: Typed.TypedTerm Syntax.TableName -> Typed.TypedTerm Syntax.InsertionTarget +insertionTarget x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.InsertionTarget"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.InsertionTarget +insertionTargetInsertionTarget :: Typed.TypedName Syntax.InsertionTarget +insertionTargetInsertionTarget = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.InsertionTarget") + +-- | DSL constructor for the hydra.ext.sql.syntax.IntervalLiteral wrapper +intervalLiteral :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.IntervalLiteral +intervalLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.IntervalLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.IntervalLiteral +intervalLiteralIntervalLiteral :: Typed.TypedName Syntax.IntervalLiteral +intervalLiteralIntervalLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.IntervalLiteral") + +-- | DSL constructor for the hydra.ext.sql.syntax.IntervalType wrapper +intervalType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.IntervalType +intervalType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.IntervalType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.IntervalType +intervalTypeIntervalType :: Typed.TypedName Syntax.IntervalType +intervalTypeIntervalType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.IntervalType") + +-- | DSL constructor for the hydra.ext.sql.syntax.IntervalValueExpression wrapper +intervalValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.IntervalValueExpression +intervalValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.IntervalValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.IntervalValueExpression +intervalValueExpressionIntervalValueExpression :: Typed.TypedName Syntax.IntervalValueExpression +intervalValueExpressionIntervalValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.IntervalValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.LargeObjectLength wrapper +largeObjectLength :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.LargeObjectLength +largeObjectLength x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.LargeObjectLength"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.LargeObjectLength +largeObjectLengthLargeObjectLength :: Typed.TypedName Syntax.LargeObjectLength +largeObjectLengthLargeObjectLength = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.LargeObjectLength") + +-- | DSL constructor for the hydra.ext.sql.syntax.LeftBracketOrTrigraph wrapper +leftBracketOrTrigraph :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.LeftBracketOrTrigraph +leftBracketOrTrigraph x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.LeftBracketOrTrigraph"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.LeftBracketOrTrigraph +leftBracketOrTrigraphLeftBracketOrTrigraph :: Typed.TypedName Syntax.LeftBracketOrTrigraph +leftBracketOrTrigraphLeftBracketOrTrigraph = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.LeftBracketOrTrigraph") + +-- | DSL constructor for the hydra.ext.sql.syntax.Length wrapper +length :: Typed.TypedTerm Syntax.UnsignedInteger -> Typed.TypedTerm Syntax.Length +length x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.Length"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.Length +lengthLength :: Typed.TypedName Syntax.Length +lengthLength = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.Length") + +-- | DSL constructor for the hydra.ext.sql.syntax.LikeClause wrapper +likeClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.LikeClause +likeClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.LikeClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.LikeClause +likeClauseLikeClause :: Typed.TypedName Syntax.LikeClause +likeClauseLikeClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.LikeClause") + +-- | DSL constructor for the hydra.ext.sql.syntax.MethodInvocation wrapper +methodInvocation :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.MethodInvocation +methodInvocation x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.MethodInvocation"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.MethodInvocation +methodInvocationMethodInvocation :: Typed.TypedName Syntax.MethodInvocation +methodInvocationMethodInvocation = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.MethodInvocation") + +-- | DSL constructor for the hydra.ext.sql.syntax.MultisetElementReference wrapper +multisetElementReference :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.MultisetElementReference +multisetElementReference x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.MultisetElementReference"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.MultisetElementReference +multisetElementReferenceMultisetElementReference :: Typed.TypedName Syntax.MultisetElementReference +multisetElementReferenceMultisetElementReference = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.MultisetElementReference") + +-- | DSL constructor for the hydra.ext.sql.syntax.MultisetType wrapper +multisetType :: Typed.TypedTerm Syntax.DataType -> Typed.TypedTerm Syntax.MultisetType +multisetType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.MultisetType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.MultisetType +multisetTypeMultisetType :: Typed.TypedName Syntax.MultisetType +multisetTypeMultisetType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.MultisetType") + +-- | DSL constructor for the hydra.ext.sql.syntax.MultisetValueConstructor wrapper +multisetValueConstructor :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.MultisetValueConstructor +multisetValueConstructor x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.MultisetValueConstructor"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.MultisetValueConstructor +multisetValueConstructorMultisetValueConstructor :: Typed.TypedName Syntax.MultisetValueConstructor +multisetValueConstructorMultisetValueConstructor = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.MultisetValueConstructor") + +-- | DSL constructor for the hydra.ext.sql.syntax.MultisetValueExpression wrapper +multisetValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.MultisetValueExpression +multisetValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.MultisetValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.MultisetValueExpression +multisetValueExpressionMultisetValueExpression :: Typed.TypedName Syntax.MultisetValueExpression +multisetValueExpressionMultisetValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.MultisetValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.NationalCharacterStringLiteral wrapper +nationalCharacterStringLiteral :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NationalCharacterStringLiteral +nationalCharacterStringLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.NationalCharacterStringLiteral +nationalCharacterStringLiteralNationalCharacterStringLiteral :: Typed.TypedName Syntax.NationalCharacterStringLiteral +nationalCharacterStringLiteralNationalCharacterStringLiteral = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringLiteral") + +-- | DSL constructor for the hydra.ext.sql.syntax.NationalCharacterStringType wrapper +nationalCharacterStringType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NationalCharacterStringType +nationalCharacterStringType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.NationalCharacterStringType +nationalCharacterStringTypeNationalCharacterStringType :: Typed.TypedName Syntax.NationalCharacterStringType +nationalCharacterStringTypeNationalCharacterStringType = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringType") + +-- | DSL constructor for the hydra.ext.sql.syntax.NewSpecification wrapper +newSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NewSpecification +newSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.NewSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.NewSpecification +newSpecificationNewSpecification :: Typed.TypedName Syntax.NewSpecification +newSpecificationNewSpecification = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NewSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.NextValueExpression wrapper +nextValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NextValueExpression +nextValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.NextValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.NextValueExpression +nextValueExpressionNextValueExpression :: Typed.TypedName Syntax.NextValueExpression +nextValueExpressionNextValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NextValueExpression") + +-- | DSL injection for the arrayElement variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryArrayElement :: Typed.TypedTerm Syntax.ArrayElementReference -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryArrayElement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "arrayElement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the attributeOrMethod variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryAttributeOrMethod :: Typed.TypedTerm Syntax.AttributeOrMethodReference -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryAttributeOrMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "attributeOrMethod"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the cases variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCases :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCases x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "cases"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the cast variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCast :: Typed.TypedTerm Syntax.CastSpecification -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCast x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "cast"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the collection variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCollection :: Typed.TypedTerm Syntax.CollectionValueConstructor -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryCollection x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the column variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryColumn :: Typed.TypedTerm Syntax.ColumnReference -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryColumn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the field variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryField :: Typed.TypedTerm Syntax.FieldReference -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryField x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "field"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the method variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryMethod :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "method"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the multisetElement variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryMultisetElement :: Typed.TypedTerm Syntax.MultisetElementReference -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryMultisetElement x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "multisetElement"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the new variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNew :: Typed.TypedTerm Syntax.NewSpecification -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNew x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "new"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the next variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNext :: Typed.TypedTerm Syntax.NextValueExpression -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNext x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "next"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNonparenthesizedValueExpressionPrimary :: Typed.TypedName Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryNonparenthesizedValueExpressionPrimary = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary") + +-- | DSL injection for the reference variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryReference :: Typed.TypedTerm Syntax.ReferenceResolution -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryReference x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "reference"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the routine variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryRoutine :: Typed.TypedTerm Syntax.RoutineInvocation -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryRoutine x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "routine"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the scalarSubquery variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryScalarSubquery :: Typed.TypedTerm Syntax.ScalarSubquery -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryScalarSubquery x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "scalarSubquery"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the setFunction variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimarySetFunction :: Typed.TypedTerm Syntax.SetFunctionSpecification -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimarySetFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "setFunction"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the staticMethod variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryStaticMethod :: Typed.TypedTerm Syntax.StaticMethodInvocation -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryStaticMethod x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "staticMethod"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the subtype variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimarySubtype :: Typed.TypedTerm Syntax.SubtypeTreatment -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimarySubtype x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subtype"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the unsigned variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryUnsigned :: Typed.TypedTerm Syntax.UnsignedValueSpecification -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryUnsigned x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "unsigned"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the windowFunction variant of hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryWindowFunction :: Typed.TypedTerm Syntax.WindowFunction -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +nonparenthesizedValueExpressionPrimaryWindowFunction x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "windowFunction"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the approximate variant of hydra.ext.sql.syntax.NumericType +numericTypeApproximate :: Typed.TypedTerm Syntax.ApproximateNumericType -> Typed.TypedTerm Syntax.NumericType +numericTypeApproximate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "approximate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the exact variant of hydra.ext.sql.syntax.NumericType +numericTypeExact :: Typed.TypedTerm Syntax.ExactNumericType -> Typed.TypedTerm Syntax.NumericType +numericTypeExact x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.NumericType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "exact"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.NumericType +numericTypeNumericType :: Typed.TypedName Syntax.NumericType +numericTypeNumericType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NumericType") + +-- | DSL constructor for the hydra.ext.sql.syntax.NumericValueExpression wrapper +numericValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.NumericValueExpression +numericValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.NumericValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.NumericValueExpression +numericValueExpressionNumericValueExpression :: Typed.TypedName Syntax.NumericValueExpression +numericValueExpressionNumericValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.NumericValueExpression") + +-- | DSL injection for the OVERRIDINGspSYSTEMspVALUE variant of hydra.ext.sql.syntax.OverrideClause +overrideClauseOVERRIDINGspSYSTEMspVALUE :: Typed.TypedTerm Syntax.OverrideClause +overrideClauseOVERRIDINGspSYSTEMspVALUE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.OverrideClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "OVERRIDINGspSYSTEMspVALUE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the OVERRIDINGspUSERspVALUE variant of hydra.ext.sql.syntax.OverrideClause +overrideClauseOVERRIDINGspUSERspVALUE :: Typed.TypedTerm Syntax.OverrideClause +overrideClauseOVERRIDINGspUSERspVALUE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.OverrideClause"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "OVERRIDINGspUSERspVALUE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.sql.syntax.OverrideClause +overrideClauseOverrideClause :: Typed.TypedName Syntax.OverrideClause +overrideClauseOverrideClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.OverrideClause") + +-- | DSL constructor for the hydra.ext.sql.syntax.ParenthesizedValueExpression wrapper +parenthesizedValueExpression :: Typed.TypedTerm Syntax.ValueExpression -> Typed.TypedTerm Syntax.ParenthesizedValueExpression +parenthesizedValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ParenthesizedValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ParenthesizedValueExpression +parenthesizedValueExpressionParenthesizedValueExpression :: Typed.TypedName Syntax.ParenthesizedValueExpression +parenthesizedValueExpressionParenthesizedValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ParenthesizedValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName wrapper +pathResolvedUserDefinedTypeName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName +pathResolvedUserDefinedTypeName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName +pathResolvedUserDefinedTypeNamePathResolvedUserDefinedTypeName :: Typed.TypedName Syntax.PathResolvedUserDefinedTypeName +pathResolvedUserDefinedTypeNamePathResolvedUserDefinedTypeName = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName") + +-- | DSL constructor for the hydra.ext.sql.syntax.Precision wrapper +precision :: Typed.TypedTerm Syntax.UnsignedInteger -> Typed.TypedTerm Syntax.Precision +precision x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.Precision"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.Precision +precisionPrecision :: Typed.TypedName Syntax.Precision +precisionPrecision = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.Precision") + +-- | DSL injection for the blob variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeBlob :: Typed.TypedTerm Syntax.BinaryLargeObjectStringType -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeBlob x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "blob"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the boolean variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeBoolean :: Typed.TypedTerm Syntax.BooleanType -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the datetime variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeDatetime :: Typed.TypedTerm Syntax.DatetimeType -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeDatetime x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "datetime"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the interval variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeInterval :: Typed.TypedTerm Syntax.IntervalType -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeInterval x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "interval"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalString :: Typed.TypedTerm Syntax.NationalCharacterStringType -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.PredefinedTypeNationalString +predefinedTypeNationalString type_ collate = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm collate)}]})) + +-- | DSL accessor for the collate field of hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalStringCollate :: Typed.TypedTerm Syntax.PredefinedTypeNationalString -> Typed.TypedTerm (Maybe Syntax.CollateClause) +predefinedTypeNationalStringCollate x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalStringPredefinedTypeNationalString :: Typed.TypedName Syntax.PredefinedTypeNationalString +predefinedTypeNationalStringPredefinedTypeNationalString = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString") + +-- | DSL injection for the nationalStringType variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeNationalStringType :: Typed.TypedTerm Syntax.PredefinedTypeNationalString -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeNationalStringType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "nationalStringType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the type field of hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalStringType2 :: Typed.TypedTerm Syntax.PredefinedTypeNationalString -> Typed.TypedTerm Syntax.NationalCharacterStringType +predefinedTypeNationalStringType2 x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the collate field of hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalStringWithCollate :: Typed.TypedTerm Syntax.PredefinedTypeNationalString -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.PredefinedTypeNationalString +predefinedTypeNationalStringWithCollate original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.sql.syntax.PredefinedTypeNationalString +predefinedTypeNationalStringWithType :: Typed.TypedTerm Syntax.PredefinedTypeNationalString -> Typed.TypedTerm Syntax.NationalCharacterStringType -> Typed.TypedTerm Syntax.PredefinedTypeNationalString +predefinedTypeNationalStringWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the numeric variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeNumeric :: Typed.TypedTerm Syntax.NumericType -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeNumeric x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "numeric"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.PredefinedType +predefinedTypePredefinedType :: Typed.TypedName Syntax.PredefinedType +predefinedTypePredefinedType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.PredefinedType") + +-- | DSL constructor for hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeString :: Typed.TypedTerm Syntax.CharacterStringType -> Typed.TypedTerm (Maybe Syntax.CharacterSetSpecification) -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.PredefinedTypeString +predefinedTypeString type_ characters collate = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "characters"), + Model.fieldTerm = (Typed.unTypedTerm characters)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm collate)}]})) + +-- | DSL accessor for the characters field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringCharacters :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm (Maybe Syntax.CharacterSetSpecification) +predefinedTypeStringCharacters x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "characters")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the collate field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringCollate :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm (Maybe Syntax.CollateClause) +predefinedTypeStringCollate x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringPredefinedTypeString :: Typed.TypedName Syntax.PredefinedTypeString +predefinedTypeStringPredefinedTypeString = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString") + +-- | DSL injection for the stringType variant of hydra.ext.sql.syntax.PredefinedType +predefinedTypeStringType :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm Syntax.PredefinedType +predefinedTypeStringType x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "stringType"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the type field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringType2 :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm Syntax.CharacterStringType +predefinedTypeStringType2 x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the characters field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringWithCharacters :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm (Maybe Syntax.CharacterSetSpecification) -> Typed.TypedTerm Syntax.PredefinedTypeString +predefinedTypeStringWithCharacters original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "characters"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the collate field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringWithCollate :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm (Maybe Syntax.CollateClause) -> Typed.TypedTerm Syntax.PredefinedTypeString +predefinedTypeStringWithCollate original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "characters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "characters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.sql.syntax.PredefinedTypeString +predefinedTypeStringWithType :: Typed.TypedTerm Syntax.PredefinedTypeString -> Typed.TypedTerm Syntax.CharacterStringType -> Typed.TypedTerm Syntax.PredefinedTypeString +predefinedTypeStringWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "characters"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "characters")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collate"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.PredefinedTypeString"), + Model.projectionFieldName = (Model.Name "collate")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.sql.syntax.Predicate wrapper +predicate :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.Predicate +predicate x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.Predicate"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.Predicate +predicatePredicate :: Typed.TypedName Syntax.Predicate +predicatePredicate = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.Predicate") + +-- | DSL constructor for the hydra.ext.sql.syntax.QueryExpression wrapper +queryExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.QueryExpression +queryExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.QueryExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.QueryExpression +queryExpressionQueryExpression :: Typed.TypedName Syntax.QueryExpression +queryExpressionQueryExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.QueryExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.ReferenceResolution wrapper +referenceResolution :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ReferenceResolution +referenceResolution x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ReferenceResolution"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ReferenceResolution +referenceResolutionReferenceResolution :: Typed.TypedName Syntax.ReferenceResolution +referenceResolutionReferenceResolution = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ReferenceResolution") + +-- | DSL constructor for the hydra.ext.sql.syntax.ReferenceScopeCheck wrapper +referenceScopeCheck :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ReferenceScopeCheck +referenceScopeCheck x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ReferenceScopeCheck"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ReferenceScopeCheck +referenceScopeCheckReferenceScopeCheck :: Typed.TypedName Syntax.ReferenceScopeCheck +referenceScopeCheckReferenceScopeCheck = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ReferenceScopeCheck") + +-- | DSL constructor for the hydra.ext.sql.syntax.ReferenceType wrapper +referenceType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ReferenceType +referenceType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ReferenceType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ReferenceType +referenceTypeReferenceType :: Typed.TypedName Syntax.ReferenceType +referenceTypeReferenceType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ReferenceType") + +-- | DSL constructor for the hydra.ext.sql.syntax.ReferenceValueExpression wrapper +referenceValueExpression :: Typed.TypedTerm Syntax.ValueExpressionPrimary -> Typed.TypedTerm Syntax.ReferenceValueExpression +referenceValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ReferenceValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ReferenceValueExpression +referenceValueExpressionReferenceValueExpression :: Typed.TypedName Syntax.ReferenceValueExpression +referenceValueExpressionReferenceValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ReferenceValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.RightBracketOrTrigraph wrapper +rightBracketOrTrigraph :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.RightBracketOrTrigraph +rightBracketOrTrigraph x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.RightBracketOrTrigraph"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.RightBracketOrTrigraph +rightBracketOrTrigraphRightBracketOrTrigraph :: Typed.TypedName Syntax.RightBracketOrTrigraph +rightBracketOrTrigraphRightBracketOrTrigraph = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.RightBracketOrTrigraph") + +-- | DSL constructor for the hydra.ext.sql.syntax.RoutineInvocation wrapper +routineInvocation :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.RoutineInvocation +routineInvocation x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.RoutineInvocation"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.RoutineInvocation +routineInvocationRoutineInvocation :: Typed.TypedName Syntax.RoutineInvocation +routineInvocationRoutineInvocation = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.RoutineInvocation") + +-- | DSL constructor for the hydra.ext.sql.syntax.RowType wrapper +rowType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.RowType +rowType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.RowType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.RowType +rowTypeRowType :: Typed.TypedName Syntax.RowType +rowTypeRowType = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.RowType") + +-- | DSL constructor for the hydra.ext.sql.syntax.RowValueExpression wrapper +rowValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.RowValueExpression +rowValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.RowValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.RowValueExpression +rowValueExpressionRowValueExpression :: Typed.TypedName Syntax.RowValueExpression +rowValueExpressionRowValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.RowValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.RowValueSpecialCase wrapper +rowValueSpecialCase :: Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary -> Typed.TypedTerm Syntax.RowValueSpecialCase +rowValueSpecialCase x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.RowValueSpecialCase"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.RowValueSpecialCase +rowValueSpecialCaseRowValueSpecialCase :: Typed.TypedName Syntax.RowValueSpecialCase +rowValueSpecialCaseRowValueSpecialCase = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.RowValueSpecialCase") + +-- | DSL constructor for the hydra.ext.sql.syntax.ScalarSubquery wrapper +scalarSubquery :: Typed.TypedTerm Syntax.Subquery -> Typed.TypedTerm Syntax.ScalarSubquery +scalarSubquery x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.ScalarSubquery"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.ScalarSubquery +scalarSubqueryScalarSubquery :: Typed.TypedName Syntax.ScalarSubquery +scalarSubqueryScalarSubquery = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ScalarSubquery") + +-- | DSL constructor for the hydra.ext.sql.syntax.Scale wrapper +scale :: Typed.TypedTerm Syntax.UnsignedInteger -> Typed.TypedTerm Syntax.Scale +scale x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.Scale"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.Scale +scaleScale :: Typed.TypedName Syntax.Scale +scaleScale = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.Scale") + +-- | DSL constructor for the hydra.ext.sql.syntax.SelfReferencingColumnSpecification wrapper +selfReferencingColumnSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.SelfReferencingColumnSpecification +selfReferencingColumnSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.SelfReferencingColumnSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.SelfReferencingColumnSpecification +selfReferencingColumnSpecificationSelfReferencingColumnSpecification :: Typed.TypedName Syntax.SelfReferencingColumnSpecification +selfReferencingColumnSpecificationSelfReferencingColumnSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.SelfReferencingColumnSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.SetFunctionSpecification wrapper +setFunctionSpecification :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.SetFunctionSpecification +setFunctionSpecification x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.SetFunctionSpecification"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.SetFunctionSpecification +setFunctionSpecificationSetFunctionSpecification :: Typed.TypedName Syntax.SetFunctionSpecification +setFunctionSpecificationSetFunctionSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.SetFunctionSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.StaticMethodInvocation wrapper +staticMethodInvocation :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.StaticMethodInvocation +staticMethodInvocation x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.StaticMethodInvocation"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.StaticMethodInvocation +staticMethodInvocationStaticMethodInvocation :: Typed.TypedName Syntax.StaticMethodInvocation +staticMethodInvocationStaticMethodInvocation = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.StaticMethodInvocation") + +-- | DSL constructor for the hydra.ext.sql.syntax.StringValueExpression wrapper +stringValueExpression :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.StringValueExpression +stringValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.StringValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.StringValueExpression +stringValueExpressionStringValueExpression :: Typed.TypedName Syntax.StringValueExpression +stringValueExpressionStringValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.StringValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.Subquery wrapper +subquery :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.Subquery +subquery x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.Subquery"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.Subquery +subquerySubquery :: Typed.TypedName Syntax.Subquery +subquerySubquery = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.Subquery") + +-- | DSL constructor for the hydra.ext.sql.syntax.SubtableClause wrapper +subtableClause :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.SubtableClause +subtableClause x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.SubtableClause"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.SubtableClause +subtableClauseSubtableClause :: Typed.TypedName Syntax.SubtableClause +subtableClauseSubtableClause = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.SubtableClause") + +-- | DSL constructor for the hydra.ext.sql.syntax.SubtypeTreatment wrapper +subtypeTreatment :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.SubtypeTreatment +subtypeTreatment x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.SubtypeTreatment"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.SubtypeTreatment +subtypeTreatmentSubtypeTreatment :: Typed.TypedName Syntax.SubtypeTreatment +subtypeTreatmentSubtypeTreatment = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.SubtypeTreatment") + +-- | DSL injection for the delete variant of hydra.ext.sql.syntax.TableCommitAction +tableCommitActionDelete :: Typed.TypedTerm Syntax.TableCommitAction +tableCommitActionDelete = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableCommitAction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "delete"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the preserve variant of hydra.ext.sql.syntax.TableCommitAction +tableCommitActionPreserve :: Typed.TypedTerm Syntax.TableCommitAction +tableCommitActionPreserve = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableCommitAction"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "preserve"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.sql.syntax.TableCommitAction +tableCommitActionTableCommitAction :: Typed.TypedName Syntax.TableCommitAction +tableCommitActionTableCommitAction = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableCommitAction") + +-- | DSL constructor for the hydra.ext.sql.syntax.TableConstraintDefinition wrapper +tableConstraintDefinition :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.TableConstraintDefinition +tableConstraintDefinition x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TableConstraintDefinition"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableConstraintDefinition +tableConstraintDefinitionTableConstraintDefinition :: Typed.TypedName Syntax.TableConstraintDefinition +tableConstraintDefinitionTableConstraintDefinition = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableConstraintDefinition") + +-- | DSL injection for the list variant of hydra.ext.sql.syntax.TableContentsSource +tableContentsSourceList :: Typed.TypedTerm Syntax.TableElementList -> Typed.TypedTerm Syntax.TableContentsSource +tableContentsSourceList x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "list"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the subquery variant of hydra.ext.sql.syntax.TableContentsSource +tableContentsSourceSubquery :: Typed.TypedTerm Syntax.AsSubqueryClause -> Typed.TypedTerm Syntax.TableContentsSource +tableContentsSourceSubquery x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subquery"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtable :: Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName -> Typed.TypedTerm (Maybe Syntax.SubtableClause) -> Typed.TypedTerm (Maybe Syntax.TableElementList) -> Typed.TypedTerm Syntax.TableContentsSourceSubtable +tableContentsSourceSubtable type_ subtable elements = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "subtable"), + Model.fieldTerm = (Typed.unTypedTerm subtable)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm elements)}]})) + +-- | DSL accessor for the elements field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableElements :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm (Maybe Syntax.TableElementList) +tableContentsSourceSubtableElements x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL injection for the subtableOf variant of hydra.ext.sql.syntax.TableContentsSource +tableContentsSourceSubtableOf :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm Syntax.TableContentsSource +tableContentsSourceSubtableOf x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSource"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "subtableOf"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL accessor for the subtable field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableSubtable :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm (Maybe Syntax.SubtableClause) +tableContentsSourceSubtableSubtable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "subtable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableTableContentsSourceSubtable :: Typed.TypedName Syntax.TableContentsSourceSubtable +tableContentsSourceSubtableTableContentsSourceSubtable = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable") + +-- | DSL accessor for the type field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableType :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName +tableContentsSourceSubtableType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the elements field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithElements :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm (Maybe Syntax.TableElementList) -> Typed.TypedTerm Syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithElements original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subtable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "subtable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the subtable field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithSubtable :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm (Maybe Syntax.SubtableClause) -> Typed.TypedTerm Syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithSubtable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "subtable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.sql.syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithType :: Typed.TypedTerm Syntax.TableContentsSourceSubtable -> Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName -> Typed.TypedTerm Syntax.TableContentsSourceSubtable +tableContentsSourceSubtableWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "subtable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "subtable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "elements"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable"), + Model.projectionFieldName = (Model.Name "elements")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.ext.sql.syntax.TableContentsSource +tableContentsSourceTableContentsSource :: Typed.TypedName Syntax.TableContentsSource +tableContentsSourceTableContentsSource = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableContentsSource") + +-- | DSL constructor for hydra.ext.sql.syntax.TableDefinition +tableDefinition :: Typed.TypedTerm (Maybe Syntax.TableScope) -> Typed.TypedTerm Syntax.TableName -> Typed.TypedTerm Syntax.TableContentsSource -> Typed.TypedTerm (Maybe Syntax.TableCommitAction) -> Typed.TypedTerm Syntax.TableDefinition +tableDefinition scope name source commitActions = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scope"), + Model.fieldTerm = (Typed.unTypedTerm scope)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "source"), + Model.fieldTerm = (Typed.unTypedTerm source)}, + Model.Field { + Model.fieldName = (Model.Name "commitActions"), + Model.fieldTerm = (Typed.unTypedTerm commitActions)}]})) + +-- | DSL accessor for the commitActions field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionCommitActions :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm (Maybe Syntax.TableCommitAction) +tableDefinitionCommitActions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "commitActions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionName :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm Syntax.TableName +tableDefinitionName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the scope field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionScope :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm (Maybe Syntax.TableScope) +tableDefinitionScope x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "scope")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the source field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionSource :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm Syntax.TableContentsSource +tableDefinitionSource x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "source")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableDefinition +tableDefinitionTableDefinition :: Typed.TypedName Syntax.TableDefinition +tableDefinitionTableDefinition = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableDefinition") + +-- | DSL updater for the commitActions field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionWithCommitActions :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm (Maybe Syntax.TableCommitAction) -> Typed.TypedTerm Syntax.TableDefinition +tableDefinitionWithCommitActions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "scope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "source"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "source")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitActions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionWithName :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm Syntax.TableName -> Typed.TypedTerm Syntax.TableDefinition +tableDefinitionWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "scope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "source"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "source")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitActions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "commitActions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the scope field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionWithScope :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm (Maybe Syntax.TableScope) -> Typed.TypedTerm Syntax.TableDefinition +tableDefinitionWithScope original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scope"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "source"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "source")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitActions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "commitActions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the source field of hydra.ext.sql.syntax.TableDefinition +tableDefinitionWithSource :: Typed.TypedTerm Syntax.TableDefinition -> Typed.TypedTerm Syntax.TableContentsSource -> Typed.TypedTerm Syntax.TableDefinition +tableDefinitionWithSource original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "scope"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "scope")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "source"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "commitActions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableDefinition"), + Model.projectionFieldName = (Model.Name "commitActions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the columOptions variant of hydra.ext.sql.syntax.TableElement +tableElementColumOptions :: Typed.TypedTerm Syntax.ColumnOptions -> Typed.TypedTerm Syntax.TableElement +tableElementColumOptions x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "columOptions"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the column variant of hydra.ext.sql.syntax.TableElement +tableElementColumn :: Typed.TypedTerm Syntax.ColumnDefinition -> Typed.TypedTerm Syntax.TableElement +tableElementColumn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "column"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the like variant of hydra.ext.sql.syntax.TableElement +tableElementLike :: Typed.TypedTerm Syntax.LikeClause -> Typed.TypedTerm Syntax.TableElement +tableElementLike x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "like"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.ext.sql.syntax.TableElementList +tableElementList :: Typed.TypedTerm Syntax.TableElement -> Typed.TypedTerm [Syntax.TableElement] -> Typed.TypedTerm Syntax.TableElementList +tableElementList first rest = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm first)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm rest)}]})) + +-- | DSL accessor for the first field of hydra.ext.sql.syntax.TableElementList +tableElementListFirst :: Typed.TypedTerm Syntax.TableElementList -> Typed.TypedTerm Syntax.TableElement +tableElementListFirst x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the rest field of hydra.ext.sql.syntax.TableElementList +tableElementListRest :: Typed.TypedTerm Syntax.TableElementList -> Typed.TypedTerm [Syntax.TableElement] +tableElementListRest x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableElementList +tableElementListTableElementList :: Typed.TypedName Syntax.TableElementList +tableElementListTableElementList = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableElementList") + +-- | DSL updater for the first field of hydra.ext.sql.syntax.TableElementList +tableElementListWithFirst :: Typed.TypedTerm Syntax.TableElementList -> Typed.TypedTerm Syntax.TableElement -> Typed.TypedTerm Syntax.TableElementList +tableElementListWithFirst original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.projectionFieldName = (Model.Name "rest")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rest field of hydra.ext.sql.syntax.TableElementList +tableElementListWithRest :: Typed.TypedTerm Syntax.TableElementList -> Typed.TypedTerm [Syntax.TableElement] -> Typed.TypedTerm Syntax.TableElementList +tableElementListWithRest original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "first"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElementList"), + Model.projectionFieldName = (Model.Name "first")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rest"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the selfReferencingColumn variant of hydra.ext.sql.syntax.TableElement +tableElementSelfReferencingColumn :: Typed.TypedTerm Syntax.SelfReferencingColumnSpecification -> Typed.TypedTerm Syntax.TableElement +tableElementSelfReferencingColumn x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "selfReferencingColumn"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the tableConstraint variant of hydra.ext.sql.syntax.TableElement +tableElementTableConstraint :: Typed.TypedTerm Syntax.TableConstraintDefinition -> Typed.TypedTerm Syntax.TableElement +tableElementTableConstraint x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TableElement"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "tableConstraint"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.TableElement +tableElementTableElement :: Typed.TypedName Syntax.TableElement +tableElementTableElement = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableElement") + +-- | DSL constructor for the hydra.ext.sql.syntax.TableName wrapper +tableName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TableName +tableName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TableName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableName +tableNameTableName :: Typed.TypedName Syntax.TableName +tableNameTableName = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableName") + +-- | DSL constructor for the hydra.ext.sql.syntax.TableScope wrapper +tableScope :: Typed.TypedTerm Syntax.GlobalOrLocal -> Typed.TypedTerm Syntax.TableScope +tableScope x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TableScope"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TableScope +tableScopeTableScope :: Typed.TypedName Syntax.TableScope +tableScopeTableScope = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TableScope") + +-- | DSL constructor for the hydra.ext.sql.syntax.TimeLiteral wrapper +timeLiteral :: Typed.TypedTerm Syntax.TimeString -> Typed.TypedTerm Syntax.TimeLiteral +timeLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TimeLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TimeLiteral +timeLiteralTimeLiteral :: Typed.TypedName Syntax.TimeLiteral +timeLiteralTimeLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TimeLiteral") + +-- | DSL constructor for the hydra.ext.sql.syntax.TimeString wrapper +timeString :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.TimeString +timeString x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TimeString"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TimeString +timeStringTimeString :: Typed.TypedName Syntax.TimeString +timeStringTimeString = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TimeString") + +-- | DSL constructor for the hydra.ext.sql.syntax.TimestampLiteral wrapper +timestampLiteral :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.TimestampLiteral +timestampLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.TimestampLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.TimestampLiteral +timestampLiteralTimestampLiteral :: Typed.TypedName Syntax.TimestampLiteral +timestampLiteralTimestampLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TimestampLiteral") + +-- | DSL injection for the FALSE variant of hydra.ext.sql.syntax.TruthValue +truthValueFALSE :: Typed.TypedTerm Syntax.TruthValue +truthValueFALSE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TruthValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "FALSE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the TRUE variant of hydra.ext.sql.syntax.TruthValue +truthValueTRUE :: Typed.TypedTerm Syntax.TruthValue +truthValueTRUE = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TruthValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "TRUE"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.sql.syntax.TruthValue +truthValueTruthValue :: Typed.TypedName Syntax.TruthValue +truthValueTruthValue = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.TruthValue") + +-- | DSL injection for the UNKNOWN variant of hydra.ext.sql.syntax.TruthValue +truthValueUNKNOWN :: Typed.TypedTerm Syntax.TruthValue +truthValueUNKNOWN = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.TruthValue"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "UNKNOWN"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ApproximateNumericLiteral +unApproximateNumericLiteral :: Typed.TypedTerm Syntax.ApproximateNumericLiteral -> Typed.TypedTerm String +unApproximateNumericLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ApproximateNumericLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ArrayElement +unArrayElement :: Typed.TypedTerm Syntax.ArrayElement -> Typed.TypedTerm Syntax.ValueExpression +unArrayElement x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ArrayElement")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ArrayElementReference +unArrayElementReference :: Typed.TypedTerm Syntax.ArrayElementReference -> Typed.TypedTerm () +unArrayElementReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ArrayElementReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ArrayType +unArrayType :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm () +unArrayType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ArrayType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ArrayValueConstructorByQuery +unArrayValueConstructorByQuery :: Typed.TypedTerm Syntax.ArrayValueConstructorByQuery -> Typed.TypedTerm () +unArrayValueConstructorByQuery x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByQuery")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ArrayValueExpression +unArrayValueExpression :: Typed.TypedTerm Syntax.ArrayValueExpression -> Typed.TypedTerm () +unArrayValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ArrayValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.AsSubqueryClause +unAsSubqueryClause :: Typed.TypedTerm Syntax.AsSubqueryClause -> Typed.TypedTerm () +unAsSubqueryClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.AsSubqueryClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.AttributeOrMethodReference +unAttributeOrMethodReference :: Typed.TypedTerm Syntax.AttributeOrMethodReference -> Typed.TypedTerm () +unAttributeOrMethodReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.AttributeOrMethodReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.BinaryStringLiteral +unBinaryStringLiteral :: Typed.TypedTerm Syntax.BinaryStringLiteral -> Typed.TypedTerm () +unBinaryStringLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.BinaryStringLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.BooleanPredicand +unBooleanPredicand :: Typed.TypedTerm Syntax.BooleanPredicand -> Typed.TypedTerm () +unBooleanPredicand x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.BooleanPredicand")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.BooleanType +unBooleanType :: Typed.TypedTerm Syntax.BooleanType -> Typed.TypedTerm () +unBooleanType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.BooleanType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.CaseExpression +unCaseExpression :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm () +unCaseExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.CaseExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.CastSpecification +unCastSpecification :: Typed.TypedTerm Syntax.CastSpecification -> Typed.TypedTerm () +unCastSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.CastSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.CharacterSetSpecification +unCharacterSetSpecification :: Typed.TypedTerm Syntax.CharacterSetSpecification -> Typed.TypedTerm () +unCharacterSetSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.CharacterSetSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.CharacterStringLiteral +unCharacterStringLiteral :: Typed.TypedTerm Syntax.CharacterStringLiteral -> Typed.TypedTerm String +unCharacterStringLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.CharacterStringLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.CollateClause +unCollateClause :: Typed.TypedTerm Syntax.CollateClause -> Typed.TypedTerm () +unCollateClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.CollateClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ColumnConstraintDefinition +unColumnConstraintDefinition :: Typed.TypedTerm Syntax.ColumnConstraintDefinition -> Typed.TypedTerm () +unColumnConstraintDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ColumnConstraintDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ColumnName +unColumnName :: Typed.TypedTerm Syntax.ColumnName -> Typed.TypedTerm String +unColumnName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ColumnName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ColumnOptions +unColumnOptions :: Typed.TypedTerm Syntax.ColumnOptions -> Typed.TypedTerm () +unColumnOptions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ColumnOptions")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ColumnReference +unColumnReference :: Typed.TypedTerm Syntax.ColumnReference -> Typed.TypedTerm () +unColumnReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ColumnReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor +unContextuallyTypedRowValueConstructor :: Typed.TypedTerm Syntax.ContextuallyTypedRowValueConstructor -> Typed.TypedTerm () +unContextuallyTypedRowValueConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor +unContextuallyTypedTableValueConstructor :: Typed.TypedTerm Syntax.ContextuallyTypedTableValueConstructor -> Typed.TypedTerm Syntax.ContextuallyTypedRowValueExpressionList +unContextuallyTypedTableValueConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DateLiteral +unDateLiteral :: Typed.TypedTerm Syntax.DateLiteral -> Typed.TypedTerm Syntax.DateString +unDateLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DateLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DateString +unDateString :: Typed.TypedTerm Syntax.DateString -> Typed.TypedTerm () +unDateString x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DateString")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DatetimeType +unDatetimeType :: Typed.TypedTerm Syntax.DatetimeType -> Typed.TypedTerm () +unDatetimeType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DatetimeType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DatetimeValueExpression +unDatetimeValueExpression :: Typed.TypedTerm Syntax.DatetimeValueExpression -> Typed.TypedTerm () +unDatetimeValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DatetimeValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DefaultClause +unDefaultClause :: Typed.TypedTerm Syntax.DefaultClause -> Typed.TypedTerm () +unDefaultClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DefaultClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.DomainName +unDomainName :: Typed.TypedTerm Syntax.DomainName -> Typed.TypedTerm String +unDomainName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.DomainName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ExactNumericLiteral +unExactNumericLiteral :: Typed.TypedTerm Syntax.ExactNumericLiteral -> Typed.TypedTerm String +unExactNumericLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ExactNumericLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.FieldReference +unFieldReference :: Typed.TypedTerm Syntax.FieldReference -> Typed.TypedTerm () +unFieldReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.FieldReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.FromDefault +unFromDefault :: Typed.TypedTerm Syntax.FromDefault -> Typed.TypedTerm () +unFromDefault x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.FromDefault")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.FromSubquery +unFromSubquery :: Typed.TypedTerm Syntax.FromSubquery -> Typed.TypedTerm () +unFromSubquery x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.FromSubquery")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.GeneralValueSpecification +unGeneralValueSpecification :: Typed.TypedTerm Syntax.GeneralValueSpecification -> Typed.TypedTerm () +unGeneralValueSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.GeneralValueSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.GenerationClause +unGenerationClause :: Typed.TypedTerm Syntax.GenerationClause -> Typed.TypedTerm () +unGenerationClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.GenerationClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.IdentityColumnSpecification +unIdentityColumnSpecification :: Typed.TypedTerm Syntax.IdentityColumnSpecification -> Typed.TypedTerm () +unIdentityColumnSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.IdentityColumnSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.InsertColumnList +unInsertColumnList :: Typed.TypedTerm Syntax.InsertColumnList -> Typed.TypedTerm Syntax.ColumnNameList +unInsertColumnList x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.InsertColumnList")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.InsertionTarget +unInsertionTarget :: Typed.TypedTerm Syntax.InsertionTarget -> Typed.TypedTerm Syntax.TableName +unInsertionTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.InsertionTarget")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.IntervalLiteral +unIntervalLiteral :: Typed.TypedTerm Syntax.IntervalLiteral -> Typed.TypedTerm () +unIntervalLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.IntervalLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.IntervalType +unIntervalType :: Typed.TypedTerm Syntax.IntervalType -> Typed.TypedTerm () +unIntervalType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.IntervalType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.IntervalValueExpression +unIntervalValueExpression :: Typed.TypedTerm Syntax.IntervalValueExpression -> Typed.TypedTerm () +unIntervalValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.IntervalValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.LargeObjectLength +unLargeObjectLength :: Typed.TypedTerm Syntax.LargeObjectLength -> Typed.TypedTerm () +unLargeObjectLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.LargeObjectLength")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.LeftBracketOrTrigraph +unLeftBracketOrTrigraph :: Typed.TypedTerm Syntax.LeftBracketOrTrigraph -> Typed.TypedTerm String +unLeftBracketOrTrigraph x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.LeftBracketOrTrigraph")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.Length +unLength :: Typed.TypedTerm Syntax.Length -> Typed.TypedTerm Syntax.UnsignedInteger +unLength x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.Length")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.LikeClause +unLikeClause :: Typed.TypedTerm Syntax.LikeClause -> Typed.TypedTerm () +unLikeClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.LikeClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.MethodInvocation +unMethodInvocation :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm () +unMethodInvocation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.MethodInvocation")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.MultisetElementReference +unMultisetElementReference :: Typed.TypedTerm Syntax.MultisetElementReference -> Typed.TypedTerm () +unMultisetElementReference x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.MultisetElementReference")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.MultisetType +unMultisetType :: Typed.TypedTerm Syntax.MultisetType -> Typed.TypedTerm Syntax.DataType +unMultisetType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.MultisetType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.MultisetValueConstructor +unMultisetValueConstructor :: Typed.TypedTerm Syntax.MultisetValueConstructor -> Typed.TypedTerm () +unMultisetValueConstructor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.MultisetValueConstructor")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.MultisetValueExpression +unMultisetValueExpression :: Typed.TypedTerm Syntax.MultisetValueExpression -> Typed.TypedTerm () +unMultisetValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.MultisetValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.NationalCharacterStringLiteral +unNationalCharacterStringLiteral :: Typed.TypedTerm Syntax.NationalCharacterStringLiteral -> Typed.TypedTerm () +unNationalCharacterStringLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.NationalCharacterStringType +unNationalCharacterStringType :: Typed.TypedTerm Syntax.NationalCharacterStringType -> Typed.TypedTerm () +unNationalCharacterStringType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.NationalCharacterStringType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.NewSpecification +unNewSpecification :: Typed.TypedTerm Syntax.NewSpecification -> Typed.TypedTerm () +unNewSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.NewSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.NextValueExpression +unNextValueExpression :: Typed.TypedTerm Syntax.NextValueExpression -> Typed.TypedTerm () +unNextValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.NextValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.NumericValueExpression +unNumericValueExpression :: Typed.TypedTerm Syntax.NumericValueExpression -> Typed.TypedTerm () +unNumericValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.NumericValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ParenthesizedValueExpression +unParenthesizedValueExpression :: Typed.TypedTerm Syntax.ParenthesizedValueExpression -> Typed.TypedTerm Syntax.ValueExpression +unParenthesizedValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ParenthesizedValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName +unPathResolvedUserDefinedTypeName :: Typed.TypedTerm Syntax.PathResolvedUserDefinedTypeName -> Typed.TypedTerm String +unPathResolvedUserDefinedTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.Precision +unPrecision :: Typed.TypedTerm Syntax.Precision -> Typed.TypedTerm Syntax.UnsignedInteger +unPrecision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.Precision")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.Predicate +unPredicate :: Typed.TypedTerm Syntax.Predicate -> Typed.TypedTerm () +unPredicate x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.Predicate")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.QueryExpression +unQueryExpression :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm () +unQueryExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.QueryExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ReferenceResolution +unReferenceResolution :: Typed.TypedTerm Syntax.ReferenceResolution -> Typed.TypedTerm () +unReferenceResolution x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ReferenceResolution")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ReferenceScopeCheck +unReferenceScopeCheck :: Typed.TypedTerm Syntax.ReferenceScopeCheck -> Typed.TypedTerm () +unReferenceScopeCheck x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ReferenceScopeCheck")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ReferenceType +unReferenceType :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm () +unReferenceType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ReferenceType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ReferenceValueExpression +unReferenceValueExpression :: Typed.TypedTerm Syntax.ReferenceValueExpression -> Typed.TypedTerm Syntax.ValueExpressionPrimary +unReferenceValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ReferenceValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.RightBracketOrTrigraph +unRightBracketOrTrigraph :: Typed.TypedTerm Syntax.RightBracketOrTrigraph -> Typed.TypedTerm String +unRightBracketOrTrigraph x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.RightBracketOrTrigraph")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.RoutineInvocation +unRoutineInvocation :: Typed.TypedTerm Syntax.RoutineInvocation -> Typed.TypedTerm () +unRoutineInvocation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.RoutineInvocation")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.RowType +unRowType :: Typed.TypedTerm Syntax.RowType -> Typed.TypedTerm () +unRowType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.RowType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.RowValueExpression +unRowValueExpression :: Typed.TypedTerm Syntax.RowValueExpression -> Typed.TypedTerm () +unRowValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.RowValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.RowValueSpecialCase +unRowValueSpecialCase :: Typed.TypedTerm Syntax.RowValueSpecialCase -> Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary +unRowValueSpecialCase x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.RowValueSpecialCase")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.ScalarSubquery +unScalarSubquery :: Typed.TypedTerm Syntax.ScalarSubquery -> Typed.TypedTerm Syntax.Subquery +unScalarSubquery x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.ScalarSubquery")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.Scale +unScale :: Typed.TypedTerm Syntax.Scale -> Typed.TypedTerm Syntax.UnsignedInteger +unScale x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.Scale")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.SelfReferencingColumnSpecification +unSelfReferencingColumnSpecification :: Typed.TypedTerm Syntax.SelfReferencingColumnSpecification -> Typed.TypedTerm () +unSelfReferencingColumnSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.SelfReferencingColumnSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.SetFunctionSpecification +unSetFunctionSpecification :: Typed.TypedTerm Syntax.SetFunctionSpecification -> Typed.TypedTerm () +unSetFunctionSpecification x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.SetFunctionSpecification")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.StaticMethodInvocation +unStaticMethodInvocation :: Typed.TypedTerm Syntax.StaticMethodInvocation -> Typed.TypedTerm () +unStaticMethodInvocation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.StaticMethodInvocation")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.StringValueExpression +unStringValueExpression :: Typed.TypedTerm Syntax.StringValueExpression -> Typed.TypedTerm () +unStringValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.StringValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.Subquery +unSubquery :: Typed.TypedTerm Syntax.Subquery -> Typed.TypedTerm Syntax.QueryExpression +unSubquery x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.Subquery")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.SubtableClause +unSubtableClause :: Typed.TypedTerm Syntax.SubtableClause -> Typed.TypedTerm () +unSubtableClause x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.SubtableClause")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.SubtypeTreatment +unSubtypeTreatment :: Typed.TypedTerm Syntax.SubtypeTreatment -> Typed.TypedTerm () +unSubtypeTreatment x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.SubtypeTreatment")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TableConstraintDefinition +unTableConstraintDefinition :: Typed.TypedTerm Syntax.TableConstraintDefinition -> Typed.TypedTerm () +unTableConstraintDefinition x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TableConstraintDefinition")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TableName +unTableName :: Typed.TypedTerm Syntax.TableName -> Typed.TypedTerm String +unTableName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TableName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TableScope +unTableScope :: Typed.TypedTerm Syntax.TableScope -> Typed.TypedTerm Syntax.GlobalOrLocal +unTableScope x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TableScope")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TimeLiteral +unTimeLiteral :: Typed.TypedTerm Syntax.TimeLiteral -> Typed.TypedTerm Syntax.TimeString +unTimeLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TimeLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TimeString +unTimeString :: Typed.TypedTerm Syntax.TimeString -> Typed.TypedTerm () +unTimeString x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TimeString")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.TimestampLiteral +unTimestampLiteral :: Typed.TypedTerm Syntax.TimestampLiteral -> Typed.TypedTerm () +unTimestampLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.TimestampLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.UnicodeCharacterStringLiteral +unUnicodeCharacterStringLiteral :: Typed.TypedTerm Syntax.UnicodeCharacterStringLiteral -> Typed.TypedTerm () +unUnicodeCharacterStringLiteral x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.UnicodeCharacterStringLiteral")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.UnsignedInteger +unUnsignedInteger :: Typed.TypedTerm Syntax.UnsignedInteger -> Typed.TypedTerm String +unUnsignedInteger x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.UnsignedInteger")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.UserDefinedTypeValueExpression +unUserDefinedTypeValueExpression :: Typed.TypedTerm Syntax.UserDefinedTypeValueExpression -> Typed.TypedTerm Syntax.ValueExpressionPrimary +unUserDefinedTypeValueExpression x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.UserDefinedTypeValueExpression")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.sql.syntax.WindowFunction +unWindowFunction :: Typed.TypedTerm Syntax.WindowFunction -> Typed.TypedTerm () +unWindowFunction x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.sql.syntax.WindowFunction")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.sql.syntax.UnicodeCharacterStringLiteral wrapper +unicodeCharacterStringLiteral :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.UnicodeCharacterStringLiteral +unicodeCharacterStringLiteral x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.UnicodeCharacterStringLiteral"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.UnicodeCharacterStringLiteral +unicodeCharacterStringLiteralUnicodeCharacterStringLiteral :: Typed.TypedName Syntax.UnicodeCharacterStringLiteral +unicodeCharacterStringLiteralUnicodeCharacterStringLiteral = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UnicodeCharacterStringLiteral") + +-- | DSL constructor for the hydra.ext.sql.syntax.UnsignedInteger wrapper +unsignedInteger :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.UnsignedInteger +unsignedInteger x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedInteger"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.UnsignedInteger +unsignedIntegerUnsignedInteger :: Typed.TypedName Syntax.UnsignedInteger +unsignedIntegerUnsignedInteger = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UnsignedInteger") + +-- | DSL injection for the general variant of hydra.ext.sql.syntax.UnsignedLiteral +unsignedLiteralGeneral :: Typed.TypedTerm Syntax.GeneralLiteral -> Typed.TypedTerm Syntax.UnsignedLiteral +unsignedLiteralGeneral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "general"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the numeric variant of hydra.ext.sql.syntax.UnsignedLiteral +unsignedLiteralNumeric :: Typed.TypedTerm Syntax.UnsignedNumericLiteral -> Typed.TypedTerm Syntax.UnsignedLiteral +unsignedLiteralNumeric x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "numeric"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.UnsignedLiteral +unsignedLiteralUnsignedLiteral :: Typed.TypedName Syntax.UnsignedLiteral +unsignedLiteralUnsignedLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UnsignedLiteral") + +-- | DSL injection for the approximate variant of hydra.ext.sql.syntax.UnsignedNumericLiteral +unsignedNumericLiteralApproximate :: Typed.TypedTerm Syntax.ApproximateNumericLiteral -> Typed.TypedTerm Syntax.UnsignedNumericLiteral +unsignedNumericLiteralApproximate x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedNumericLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "approximate"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the exact variant of hydra.ext.sql.syntax.UnsignedNumericLiteral +unsignedNumericLiteralExact :: Typed.TypedTerm Syntax.ExactNumericLiteral -> Typed.TypedTerm Syntax.UnsignedNumericLiteral +unsignedNumericLiteralExact x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedNumericLiteral"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "exact"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.UnsignedNumericLiteral +unsignedNumericLiteralUnsignedNumericLiteral :: Typed.TypedName Syntax.UnsignedNumericLiteral +unsignedNumericLiteralUnsignedNumericLiteral = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UnsignedNumericLiteral") + +-- | DSL injection for the general variant of hydra.ext.sql.syntax.UnsignedValueSpecification +unsignedValueSpecificationGeneral :: Typed.TypedTerm Syntax.GeneralValueSpecification -> Typed.TypedTerm Syntax.UnsignedValueSpecification +unsignedValueSpecificationGeneral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedValueSpecification"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "general"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the literal variant of hydra.ext.sql.syntax.UnsignedValueSpecification +unsignedValueSpecificationLiteral :: Typed.TypedTerm Syntax.UnsignedLiteral -> Typed.TypedTerm Syntax.UnsignedValueSpecification +unsignedValueSpecificationLiteral x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.UnsignedValueSpecification"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "literal"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.UnsignedValueSpecification +unsignedValueSpecificationUnsignedValueSpecification :: Typed.TypedName Syntax.UnsignedValueSpecification +unsignedValueSpecificationUnsignedValueSpecification = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UnsignedValueSpecification") + +-- | DSL constructor for the hydra.ext.sql.syntax.UserDefinedTypeValueExpression wrapper +userDefinedTypeValueExpression :: Typed.TypedTerm Syntax.ValueExpressionPrimary -> Typed.TypedTerm Syntax.UserDefinedTypeValueExpression +userDefinedTypeValueExpression x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.UserDefinedTypeValueExpression"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.UserDefinedTypeValueExpression +userDefinedTypeValueExpressionUserDefinedTypeValueExpression :: Typed.TypedName Syntax.UserDefinedTypeValueExpression +userDefinedTypeValueExpressionUserDefinedTypeValueExpression = + Typed.TypedName (Model.Name "hydra.ext.sql.syntax.UserDefinedTypeValueExpression") + +-- | DSL injection for the boolean variant of hydra.ext.sql.syntax.ValueExpression +valueExpressionBoolean :: Typed.TypedTerm Syntax.BooleanValueExpression -> Typed.TypedTerm Syntax.ValueExpression +valueExpressionBoolean x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "boolean"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the common variant of hydra.ext.sql.syntax.ValueExpression +valueExpressionCommon :: Typed.TypedTerm Syntax.CommonValueExpression -> Typed.TypedTerm Syntax.ValueExpression +valueExpressionCommon x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "common"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the noparens variant of hydra.ext.sql.syntax.ValueExpressionPrimary +valueExpressionPrimaryNoparens :: Typed.TypedTerm Syntax.NonparenthesizedValueExpressionPrimary -> Typed.TypedTerm Syntax.ValueExpressionPrimary +valueExpressionPrimaryNoparens x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "noparens"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the parens variant of hydra.ext.sql.syntax.ValueExpressionPrimary +valueExpressionPrimaryParens :: Typed.TypedTerm Syntax.ParenthesizedValueExpression -> Typed.TypedTerm Syntax.ValueExpressionPrimary +valueExpressionPrimaryParens x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ValueExpressionPrimary"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parens"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.ValueExpressionPrimary +valueExpressionPrimaryValueExpressionPrimary :: Typed.TypedName Syntax.ValueExpressionPrimary +valueExpressionPrimaryValueExpressionPrimary = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ValueExpressionPrimary") + +-- | DSL injection for the row variant of hydra.ext.sql.syntax.ValueExpression +valueExpressionRow :: Typed.TypedTerm Syntax.RowValueExpression -> Typed.TypedTerm Syntax.ValueExpression +valueExpressionRow x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.sql.syntax.ValueExpression"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "row"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.sql.syntax.ValueExpression +valueExpressionValueExpression :: Typed.TypedName Syntax.ValueExpression +valueExpressionValueExpression = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.ValueExpression") + +-- | DSL constructor for the hydra.ext.sql.syntax.WindowFunction wrapper +windowFunction :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.WindowFunction +windowFunction x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.sql.syntax.WindowFunction"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.sql.syntax.WindowFunction +windowFunctionWindowFunction :: Typed.TypedName Syntax.WindowFunction +windowFunctionWindowFunction = Typed.TypedName (Model.Name "hydra.ext.sql.syntax.WindowFunction") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Stac/Items.hs b/src/main/haskell/Hydra/Ext/Dsl/Stac/Items.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Stac/Items.hs @@ -0,0 +1,1015 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.stac.items + +module Hydra.Ext.Dsl.Stac.Items where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Dsl.Geojson.Model as DslGeojsonModel +import qualified Hydra.Ext.Dsl.Iana.Linkrelations as IanaLinkrelations +import qualified Hydra.Ext.Geojson.Model as GeojsonModel +import qualified Hydra.Ext.Iana.Linkrelations as Linkrelations +import qualified Hydra.Ext.Stac.Items as Items +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.ext.stac.items.Asset +asset :: Typed.TypedTerm Items.Uri -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm [Items.Role] -> Typed.TypedTerm Items.Asset +asset href title description type_ roles = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Typed.unTypedTerm href)}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Typed.unTypedTerm title)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Typed.unTypedTerm roles)}]})) + +-- | DSL name token for hydra.ext.stac.items.Asset +assetAsset :: Typed.TypedName Items.Asset +assetAsset = Typed.TypedName (Model.Name "hydra.ext.stac.items.Asset") + +-- | DSL accessor for the description field of hydra.ext.stac.items.Asset +assetDescription :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) +assetDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the href field of hydra.ext.stac.items.Asset +assetHref :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm Items.Uri +assetHref x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the roles field of hydra.ext.stac.items.Asset +assetRoles :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm [Items.Role] +assetRoles x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "roles")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the title field of hydra.ext.stac.items.Asset +assetTitle :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) +assetTitle x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.stac.items.Asset +assetType :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe Items.MediaType) +assetType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the description field of hydra.ext.stac.items.Asset +assetWithDescription :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Asset +assetWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "roles")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the href field of hydra.ext.stac.items.Asset +assetWithHref :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm Items.Uri -> Typed.TypedTerm Items.Asset +assetWithHref original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "roles")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the roles field of hydra.ext.stac.items.Asset +assetWithRoles :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm [Items.Role] -> Typed.TypedTerm Items.Asset +assetWithRoles original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the title field of hydra.ext.stac.items.Asset +assetWithTitle :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Asset +assetWithTitle original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "roles")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the type field of hydra.ext.stac.items.Asset +assetWithType :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm Items.Asset +assetWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "roles"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"), + Model.projectionFieldName = (Model.Name "roles")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.stac.items.Item +item :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm [Items.Url] -> Typed.TypedTerm [Items.Link] -> Typed.TypedTerm (M.Map String Items.Asset) -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm Items.Item +item feature stacVersion stacExtensions links assets collection = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Typed.unTypedTerm feature)}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Typed.unTypedTerm stacVersion)}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Typed.unTypedTerm stacExtensions)}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Typed.unTypedTerm links)}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Typed.unTypedTerm assets)}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm collection)}]})) + +-- | DSL accessor for the assets field of hydra.ext.stac.items.Item +itemAssets :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (M.Map String Items.Asset) +itemAssets x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the collection field of hydra.ext.stac.items.Item +itemCollection :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (Maybe GeojsonModel.Id) +itemCollection x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the feature field of hydra.ext.stac.items.Item +itemFeature :: Typed.TypedTerm Items.Item -> Typed.TypedTerm GeojsonModel.Feature +itemFeature x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.Item +itemItem :: Typed.TypedName Items.Item +itemItem = Typed.TypedName (Model.Name "hydra.ext.stac.items.Item") + +-- | DSL accessor for the links field of hydra.ext.stac.items.Item +itemLinks :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Link] +itemLinks x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the stacExtensions field of hydra.ext.stac.items.Item +itemStacExtensions :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Url] +itemStacExtensions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the stacVersion field of hydra.ext.stac.items.Item +itemStacVersion :: Typed.TypedTerm Items.Item -> Typed.TypedTerm Items.StacVersion +itemStacVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the assets field of hydra.ext.stac.items.Item +itemWithAssets :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (M.Map String Items.Asset) -> Typed.TypedTerm Items.Item +itemWithAssets original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the collection field of hydra.ext.stac.items.Item +itemWithCollection :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm Items.Item +itemWithCollection original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the feature field of hydra.ext.stac.items.Item +itemWithFeature :: Typed.TypedTerm Items.Item -> Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm Items.Item +itemWithFeature original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the links field of hydra.ext.stac.items.Item +itemWithLinks :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Link] -> Typed.TypedTerm Items.Item +itemWithLinks original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the stacExtensions field of hydra.ext.stac.items.Item +itemWithStacExtensions :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Url] -> Typed.TypedTerm Items.Item +itemWithStacExtensions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the stacVersion field of hydra.ext.stac.items.Item +itemWithStacVersion :: Typed.TypedTerm Items.Item -> Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm Items.Item +itemWithStacVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "feature"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "feature")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "stacVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "stacExtensions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "stacExtensions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "links"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "links")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "assets"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "assets")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"), + Model.projectionFieldName = (Model.Name "collection")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.ext.stac.items.Link +link :: Typed.TypedTerm Items.Url -> Typed.TypedTerm Items.RelationType -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Link +link href rel type_ title = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Typed.unTypedTerm href)}, + Model.Field { + Model.fieldName = (Model.Name "rel"), + Model.fieldTerm = (Typed.unTypedTerm rel)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Typed.unTypedTerm title)}]})) + +-- | DSL accessor for the href field of hydra.ext.stac.items.Link +linkHref :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.Url +linkHref x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.Link +linkLink :: Typed.TypedName Items.Link +linkLink = Typed.TypedName (Model.Name "hydra.ext.stac.items.Link") + +-- | DSL accessor for the rel field of hydra.ext.stac.items.Link +linkRel :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.RelationType +linkRel x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "rel")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the title field of hydra.ext.stac.items.Link +linkTitle :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe String) +linkTitle x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.ext.stac.items.Link +linkType :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe Items.MediaType) +linkType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the href field of hydra.ext.stac.items.Link +linkWithHref :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.Url -> Typed.TypedTerm Items.Link +linkWithHref original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "rel"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "rel")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rel field of hydra.ext.stac.items.Link +linkWithRel :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.RelationType -> Typed.TypedTerm Items.Link +linkWithRel original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rel"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the title field of hydra.ext.stac.items.Link +linkWithTitle :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Link +linkWithTitle original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rel"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "rel")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.ext.stac.items.Link +linkWithType :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm Items.Link +linkWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "href"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "href")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "rel"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "rel")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "title"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"), + Model.projectionFieldName = (Model.Name "title")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.ext.stac.items.MediaType wrapper +mediaType :: Typed.TypedTerm String -> Typed.TypedTerm Items.MediaType +mediaType x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.MediaType"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.MediaType +mediaTypeMediaType :: Typed.TypedName Items.MediaType +mediaTypeMediaType = Typed.TypedName (Model.Name "hydra.ext.stac.items.MediaType") + +-- | DSL injection for the iana variant of hydra.ext.stac.items.RelationType +relationTypeIana :: Typed.TypedTerm Linkrelations.LinkRelationType -> Typed.TypedTerm Items.RelationType +relationTypeIana x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "iana"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the other variant of hydra.ext.stac.items.RelationType +relationTypeOther :: Typed.TypedTerm String -> Typed.TypedTerm Items.RelationType +relationTypeOther x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "other"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.ext.stac.items.RelationType +relationTypeRelationType :: Typed.TypedName Items.RelationType +relationTypeRelationType = Typed.TypedName (Model.Name "hydra.ext.stac.items.RelationType") + +-- | DSL injection for the stac variant of hydra.ext.stac.items.RelationType +relationTypeStac :: Typed.TypedTerm Items.StacRelationType -> Typed.TypedTerm Items.RelationType +relationTypeStac x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "stac"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the data variant of hydra.ext.stac.items.Role +roleData :: Typed.TypedTerm Items.Role +roleData = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "data"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the metadata variant of hydra.ext.stac.items.Role +roleMetadata :: Typed.TypedTerm Items.Role +roleMetadata = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the other variant of hydra.ext.stac.items.Role +roleOther :: Typed.TypedTerm String -> Typed.TypedTerm Items.Role +roleOther x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "other"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the overview variant of hydra.ext.stac.items.Role +roleOverview :: Typed.TypedTerm Items.Role +roleOverview = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "overview"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.stac.items.Role +roleRole :: Typed.TypedName Items.Role +roleRole = Typed.TypedName (Model.Name "hydra.ext.stac.items.Role") + +-- | DSL injection for the thumbnail variant of hydra.ext.stac.items.Role +roleThumbnail :: Typed.TypedTerm Items.Role +roleThumbnail = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "thumbnail"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the collection variant of hydra.ext.stac.items.StacRelationType +stacRelationTypeCollection :: Typed.TypedTerm Items.StacRelationType +stacRelationTypeCollection = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "collection"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the derivedFrom variant of hydra.ext.stac.items.StacRelationType +stacRelationTypeDerivedFrom :: Typed.TypedTerm Items.StacRelationType +stacRelationTypeDerivedFrom = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "derivedFrom"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the parent variant of hydra.ext.stac.items.StacRelationType +stacRelationTypeParent :: Typed.TypedTerm Items.StacRelationType +stacRelationTypeParent = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "parent"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the root variant of hydra.ext.stac.items.StacRelationType +stacRelationTypeRoot :: Typed.TypedTerm Items.StacRelationType +stacRelationTypeRoot = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "root"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the self variant of hydra.ext.stac.items.StacRelationType +stacRelationTypeSelf :: Typed.TypedTerm Items.StacRelationType +stacRelationTypeSelf = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "self"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.stac.items.StacRelationType +stacRelationTypeStacRelationType :: Typed.TypedName Items.StacRelationType +stacRelationTypeStacRelationType = Typed.TypedName (Model.Name "hydra.ext.stac.items.StacRelationType") + +-- | DSL constructor for the hydra.ext.stac.items.StacVersion wrapper +stacVersion :: Typed.TypedTerm String -> Typed.TypedTerm Items.StacVersion +stacVersion x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.StacVersion"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.StacVersion +stacVersionStacVersion :: Typed.TypedName Items.StacVersion +stacVersionStacVersion = Typed.TypedName (Model.Name "hydra.ext.stac.items.StacVersion") + +-- | DSL accessor for the body of hydra.ext.stac.items.MediaType +unMediaType :: Typed.TypedTerm Items.MediaType -> Typed.TypedTerm String +unMediaType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.MediaType")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.stac.items.StacVersion +unStacVersion :: Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm String +unStacVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.StacVersion")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.stac.items.Uri +unUri :: Typed.TypedTerm Items.Uri -> Typed.TypedTerm String +unUri x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.Uri")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.ext.stac.items.Url +unUrl :: Typed.TypedTerm Items.Url -> Typed.TypedTerm String +unUrl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.Url")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL constructor for the hydra.ext.stac.items.Uri wrapper +uri :: Typed.TypedTerm String -> Typed.TypedTerm Items.Uri +uri x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.Uri"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.Uri +uriUri :: Typed.TypedName Items.Uri +uriUri = Typed.TypedName (Model.Name "hydra.ext.stac.items.Uri") + +-- | DSL constructor for the hydra.ext.stac.items.Url wrapper +url :: Typed.TypedTerm String -> Typed.TypedTerm Items.Url +url x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.Url"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.stac.items.Url +urlUrl :: Typed.TypedName Items.Url +urlUrl = Typed.TypedName (Model.Name "hydra.ext.stac.items.Url") diff --git a/src/main/haskell/Hydra/Ext/Dsl/Workflow.hs b/src/main/haskell/Hydra/Ext/Dsl/Workflow.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Dsl/Workflow.hs @@ -0,0 +1,297 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.ext.workflow + +module Hydra.Ext.Dsl.Workflow where + +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Ext.Workflow as Workflow +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpec :: Typed.TypedTerm [Packaging.Module] -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Workflow.HydraSchemaSpec +hydraSchemaSpec modules typeName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modules"), + Model.fieldTerm = (Typed.unTypedTerm modules)}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm typeName)}]})) + +-- | DSL name token for hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpecHydraSchemaSpec :: Typed.TypedName Workflow.HydraSchemaSpec +hydraSchemaSpecHydraSchemaSpec = Typed.TypedName (Model.Name "hydra.ext.workflow.HydraSchemaSpec") + +-- | DSL accessor for the modules field of hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpecModules :: Typed.TypedTerm Workflow.HydraSchemaSpec -> Typed.TypedTerm [Packaging.Module] +hydraSchemaSpecModules x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.projectionFieldName = (Model.Name "modules")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the typeName field of hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpecTypeName :: Typed.TypedTerm Workflow.HydraSchemaSpec -> Typed.TypedTerm Model.Name +hydraSchemaSpecTypeName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the modules field of hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpecWithModules :: Typed.TypedTerm Workflow.HydraSchemaSpec -> Typed.TypedTerm [Packaging.Module] -> Typed.TypedTerm Workflow.HydraSchemaSpec +hydraSchemaSpecWithModules original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modules"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.projectionFieldName = (Model.Name "typeName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the typeName field of hydra.ext.workflow.HydraSchemaSpec +hydraSchemaSpecWithTypeName :: Typed.TypedTerm Workflow.HydraSchemaSpec -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Workflow.HydraSchemaSpec +hydraSchemaSpecWithTypeName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "modules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.HydraSchemaSpec"), + Model.projectionFieldName = (Model.Name "modules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "typeName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the file variant of hydra.ext.workflow.SchemaSpec +schemaSpecFile :: Typed.TypedTerm String -> Typed.TypedTerm Workflow.SchemaSpec +schemaSpecFile x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.workflow.SchemaSpec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "file"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the hydra variant of hydra.ext.workflow.SchemaSpec +schemaSpecHydra :: Typed.TypedTerm Workflow.HydraSchemaSpec -> Typed.TypedTerm Workflow.SchemaSpec +schemaSpecHydra x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.workflow.SchemaSpec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "hydra"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL injection for the provided variant of hydra.ext.workflow.SchemaSpec +schemaSpecProvided :: Typed.TypedTerm Workflow.SchemaSpec +schemaSpecProvided = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.ext.workflow.SchemaSpec"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "provided"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.ext.workflow.SchemaSpec +schemaSpecSchemaSpec :: Typed.TypedName Workflow.SchemaSpec +schemaSpecSchemaSpec = Typed.TypedName (Model.Name "hydra.ext.workflow.SchemaSpec") + +-- | DSL constructor for hydra.ext.workflow.TransformWorkflow +transformWorkflow :: Typed.TypedTerm String -> Typed.TypedTerm Workflow.SchemaSpec -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Workflow.TransformWorkflow +transformWorkflow name schemaSpec srcDir destDir = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "schemaSpec"), + Model.fieldTerm = (Typed.unTypedTerm schemaSpec)}, + Model.Field { + Model.fieldName = (Model.Name "srcDir"), + Model.fieldTerm = (Typed.unTypedTerm srcDir)}, + Model.Field { + Model.fieldName = (Model.Name "destDir"), + Model.fieldTerm = (Typed.unTypedTerm destDir)}]})) + +-- | DSL accessor for the destDir field of hydra.ext.workflow.TransformWorkflow +transformWorkflowDestDir :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String +transformWorkflowDestDir x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "destDir")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.ext.workflow.TransformWorkflow +transformWorkflowName :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String +transformWorkflowName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the schemaSpec field of hydra.ext.workflow.TransformWorkflow +transformWorkflowSchemaSpec :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm Workflow.SchemaSpec +transformWorkflowSchemaSpec x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "schemaSpec")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the srcDir field of hydra.ext.workflow.TransformWorkflow +transformWorkflowSrcDir :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String +transformWorkflowSrcDir x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "srcDir")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.ext.workflow.TransformWorkflow +transformWorkflowTransformWorkflow :: Typed.TypedName Workflow.TransformWorkflow +transformWorkflowTransformWorkflow = Typed.TypedName (Model.Name "hydra.ext.workflow.TransformWorkflow") + +-- | DSL updater for the destDir field of hydra.ext.workflow.TransformWorkflow +transformWorkflowWithDestDir :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String -> Typed.TypedTerm Workflow.TransformWorkflow +transformWorkflowWithDestDir original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemaSpec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "schemaSpec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "srcDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "srcDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destDir"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.ext.workflow.TransformWorkflow +transformWorkflowWithName :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String -> Typed.TypedTerm Workflow.TransformWorkflow +transformWorkflowWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "schemaSpec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "schemaSpec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "srcDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "srcDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "destDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the schemaSpec field of hydra.ext.workflow.TransformWorkflow +transformWorkflowWithSchemaSpec :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm Workflow.SchemaSpec -> Typed.TypedTerm Workflow.TransformWorkflow +transformWorkflowWithSchemaSpec original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemaSpec"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "srcDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "srcDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "destDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the srcDir field of hydra.ext.workflow.TransformWorkflow +transformWorkflowWithSrcDir :: Typed.TypedTerm Workflow.TransformWorkflow -> Typed.TypedTerm String -> Typed.TypedTerm Workflow.TransformWorkflow +transformWorkflowWithSrcDir original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "schemaSpec"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "schemaSpec")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "srcDir"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "destDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.ext.workflow.TransformWorkflow"), + Model.projectionFieldName = (Model.Name "destDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Ext/Geojson/Model.hs b/src/main/haskell/Hydra/Ext/Geojson/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Geojson/Model.hs @@ -0,0 +1,230 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A GeoJSON model based on the specification at https://www.rfc-editor.org/rfc/rfc7946. This model provides some additional structure beyond the JSON encoding described in the specification; For example, it provides MultiPoint not as an object with an array of coordinates which encode points, but as an array of Points. A BoundingBox is not simply an list of numbers, but a list of CoordinateRanges. + +module Hydra.Ext.Geojson.Model where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | A GeoJSON object MAY have a member named "bbox" to include information on the coordinate range for its Geometries, Features, or FeatureCollections. The value of the bbox member MUST be an array of length 2*n where n is the number of dimensions represented in the contained geometries, with all axes of the most southwesterly point followed by all axes of the more northeasterly point. The axes order of a bbox follows the axes order of geometries. +newtype BoundingBox = + BoundingBox { + unBoundingBox :: [CoordinateRange]} + deriving (Eq, Ord, Read, Show) + +_BoundingBox = Model.Name "hydra.ext.geojson.model.BoundingBox" + +-- | The minimum and maximum values along one axis of a bounding box +data CoordinateRange = + CoordinateRange { + coordinateRangeMin :: Double, + coordinateRangeMax :: Double} + deriving (Eq, Ord, Read, Show) + +_CoordinateRange = Model.Name "hydra.ext.geojson.model.CoordinateRange" + +_CoordinateRange_min = Model.Name "min" + +_CoordinateRange_max = Model.Name "max" + +-- | A Feature object represents a spatially bounded thing. Every Feature object is a GeoJSON object no matter where it occurs in a GeoJSON text. +data Feature = + Feature { + -- | A Feature object has a member with the name "geometry". The value of the geometry member SHALL be either a Geometry object as defined above or, in the case that the Feature is unlocated, a JSON null value. + featureGeometry :: (Maybe Geometry), + -- | A Feature object has a member with the name "properties". The value of the properties member is an object (any JSON object or a JSON null value). + featureProperties :: (Maybe (M.Map String JsonModel.Value)), + -- | If a Feature has a commonly used identifier, that identifier SHOULD be included as a member of the Feature object with the name "id", and the value of this member is either a JSON string or number. + featureId :: (Maybe Id), + featureBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_Feature = Model.Name "hydra.ext.geojson.model.Feature" + +_Feature_geometry = Model.Name "geometry" + +_Feature_properties = Model.Name "properties" + +_Feature_id = Model.Name "id" + +_Feature_bbox = Model.Name "bbox" + +-- | A GeoJSON object with the type "FeatureCollection" is a FeatureCollection object. A FeatureCollection object has a member with the name "features". The value of "features" is a JSON array. Each element of the array is a Feature object as defined above. It is possible for this array to be empty. +data FeatureCollection = + FeatureCollection { + featureCollectionFeatures :: [Feature], + featureCollectionBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_FeatureCollection = Model.Name "hydra.ext.geojson.model.FeatureCollection" + +_FeatureCollection_features = Model.Name "features" + +_FeatureCollection_bbox = Model.Name "bbox" + +-- | A Geometry object represents points, curves, and surfaces in coordinate space. Every Geometry object is a GeoJSON object no matter where it occurs in a GeoJSON text. +data Geometry = + GeometryPoint Point | + GeometryMultiPoint MultiPoint | + GeometryLineString LineString | + GeometryMultiLineString MultiLineString | + GeometryPolygon Polygon | + GeometryMultiPolygon MultiPolygon | + GeometryGeometryCollection GeometryCollection + deriving (Eq, Ord, Read, Show) + +_Geometry = Model.Name "hydra.ext.geojson.model.Geometry" + +_Geometry_point = Model.Name "point" + +_Geometry_multiPoint = Model.Name "multiPoint" + +_Geometry_lineString = Model.Name "lineString" + +_Geometry_multiLineString = Model.Name "multiLineString" + +_Geometry_polygon = Model.Name "polygon" + +_Geometry_multiPolygon = Model.Name "multiPolygon" + +_Geometry_geometryCollection = Model.Name "geometryCollection" + +-- | A GeoJSON object with type "GeometryCollection" is a Geometry object. A GeometryCollection has a member with the name "geometries". The value of "geometries" is an array. Each element of this array is a GeoJSON Geometry object. It is possible for this array to be empty. +data GeometryCollection = + GeometryCollection { + geometryCollectionGeometries :: [Geometry], + geometryCollectionBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_GeometryCollection = Model.Name "hydra.ext.geojson.model.GeometryCollection" + +_GeometryCollection_geometries = Model.Name "geometries" + +_GeometryCollection_bbox = Model.Name "bbox" + +-- | A Feature's commonly used identifier, either a JSON string or a number +data Id = + IdNumber Double | + IdString String + deriving (Eq, Ord, Read, Show) + +_Id = Model.Name "hydra.ext.geojson.model.Id" + +_Id_number = Model.Name "number" + +_Id_string = Model.Name "string" + +-- | For type "LineString", the "coordinates" member is an array of two or more positions. +data LineString = + LineString { + lineStringCoordinates :: [Position], + lineStringBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_LineString = Model.Name "hydra.ext.geojson.model.LineString" + +_LineString_coordinates = Model.Name "coordinates" + +_LineString_bbox = Model.Name "bbox" + +-- | For type "MultiLineString", the "coordinates" member is an array of LineString coordinate arrays. +data MultiLineString = + MultiLineString { + multiLineStringCoordinates :: [LineString], + multiLineStringBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_MultiLineString = Model.Name "hydra.ext.geojson.model.MultiLineString" + +_MultiLineString_coordinates = Model.Name "coordinates" + +_MultiLineString_bbox = Model.Name "bbox" + +-- | For type "MultiPoint", the "coordinates" member is an array of positions. +data MultiPoint = + MultiPoint { + multiPointCoordinates :: [Point], + multiPointBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_MultiPoint = Model.Name "hydra.ext.geojson.model.MultiPoint" + +_MultiPoint_coordinates = Model.Name "coordinates" + +_MultiPoint_bbox = Model.Name "bbox" + +-- | For type "MultiPolygon", the "coordinates" member is an array of Polygon coordinate arrays. +data MultiPolygon = + MultiPolygon { + multiPolygonCoordinates :: [Polygon], + multiPolygonBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_MultiPolygon = Model.Name "hydra.ext.geojson.model.MultiPolygon" + +_MultiPolygon_coordinates = Model.Name "coordinates" + +_MultiPolygon_bbox = Model.Name "bbox" + +-- | A GeoJSON object represents a Geometry, Feature, or collection of Features. +data Object = + ObjectGeometry Geometry | + ObjectFeature Feature | + ObjectFeatureCollection FeatureCollection + deriving (Eq, Ord, Read, Show) + +_Object = Model.Name "hydra.ext.geojson.model.Object" + +_Object_geometry = Model.Name "geometry" + +_Object_feature = Model.Name "feature" + +_Object_featureCollection = Model.Name "featureCollection" + +-- | For type "Point", the "coordinates" member is a single position. +data Point = + Point { + pointCoordinates :: Position, + pointBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_Point = Model.Name "hydra.ext.geojson.model.Point" + +_Point_coordinates = Model.Name "coordinates" + +_Point_bbox = Model.Name "bbox" + +-- | For type "Polygon", the "coordinates" member MUST be an array of linear ring coordinate arrays. +-- | For Polygons with more than one of these rings, the first MUST be the exterior ring, and any others MUST be interior rings. The exterior ring bounds the surface, and the interior rings (if present) bound holes within the surface. +data Polygon = + Polygon { + polygonCoordinates :: [Position], + polygonBbox :: (Maybe BoundingBox)} + deriving (Eq, Ord, Read, Show) + +_Polygon = Model.Name "hydra.ext.geojson.model.Polygon" + +_Polygon_coordinates = Model.Name "coordinates" + +_Polygon_bbox = Model.Name "bbox" + +-- | A position is an array of numbers. There MUST be two or more elements. The first two elements are longitude and latitude, or easting and northing, precisely in that order and using decimal numbers. Altitude or elevation MAY be included as an optional third element. +data Position = + Position { + positionLatitude :: Double, + positionLongitude :: Double, + positionAltitude :: (Maybe Double)} + deriving (Eq, Ord, Read, Show) + +_Position = Model.Name "hydra.ext.geojson.model.Position" + +_Position_latitude = Model.Name "latitude" + +_Position_longitude = Model.Name "longitude" + +_Position_altitude = Model.Name "altitude" diff --git a/src/main/haskell/Hydra/Ext/Graphql/Coder.hs b/src/main/haskell/Hydra/Ext/Graphql/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Graphql/Coder.hs @@ -0,0 +1,259 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | GraphQL code generator: converts Hydra modules to GraphQL schema definitions + +module Hydra.Ext.Graphql.Coder where + +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Environment as Environment +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Predicates as Predicates +import qualified Hydra.Core.Print.Model as PrintModel +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Graphql.Language as Language +import qualified Hydra.Ext.Graphql.Serde as Serde +import qualified Hydra.Ext.Graphql.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Check whether a map key type is representable in GraphQL as of this coder. Only literal scalar key types are supported; any other key type fails explicitly rather than being silently dropped from the generated schema (#744). +checkMapKeyRepresentable :: Model.Type -> Either Errors.Error () +checkMapKeyRepresentable kt = + case (Strip.deannotateType kt) of + Model.TypeLiteral _ -> Right () + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Map key types other than literals are not yet supported for GraphQL encoding (dropping the key type would silently corrupt the schema); found: " (PrintModel.type_ kt)))) + +-- | Get the description from a type as a GraphQL Description +descriptionFromType :: t0 -> Graph.Graph -> Model.Type -> Either Errors.Error (Maybe Syntax.Description) +descriptionFromType cx g typ = + Eithers.map (\mval -> Optionals.map (\s -> Syntax.Description (Syntax.StringValue s)) mval) (Annotations.getTypeDescription cx g typ) + +-- | Encode a field name to a GraphQL EnumValue +encodeEnumFieldName :: Model.Name -> Syntax.EnumValue +encodeEnumFieldName name = Syntax.EnumValue (Syntax.Name (sanitize (Model.unName name))) + +-- | Encode an enum field type to a GraphQL EnumValueDefinition +encodeEnumFieldType :: t0 -> Graph.Graph -> Model.FieldType -> Either Errors.Error Syntax.EnumValueDefinition +encodeEnumFieldType cx g ft = + Eithers.bind (descriptionFromType cx g (Model.fieldTypeType ft)) (\desc -> Right (Syntax.EnumValueDefinition { + Syntax.enumValueDefinitionDescription = desc, + Syntax.enumValueDefinitionEnumValue = (encodeEnumFieldName (Model.fieldTypeName ft)), + Syntax.enumValueDefinitionDirectives = Nothing})) + +-- | Encode a field name to a GraphQL Name +encodeFieldName :: Model.Name -> Syntax.Name +encodeFieldName name = Syntax.Name (sanitize (Model.unName name)) + +-- | Encode a field type to a GraphQL FieldDefinition +encodeFieldType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.FieldType -> Either Errors.Error Syntax.FieldDefinition +encodeFieldType cx g prefixes ft = + Eithers.bind (encodeType cx g prefixes (Model.fieldTypeType ft)) (\gtype -> Eithers.bind (descriptionFromType cx g (Model.fieldTypeType ft)) (\desc -> Right (Syntax.FieldDefinition { + Syntax.fieldDefinitionDescription = desc, + Syntax.fieldDefinitionName = (encodeFieldName (Model.fieldTypeName ft)), + Syntax.fieldDefinitionArgumentsDefinition = Nothing, + Syntax.fieldDefinitionType = gtype, + Syntax.fieldDefinitionDirectives = Nothing}))) + +-- | Encode a literal type to a GraphQL NamedType +encodeLiteralType :: t0 -> Model.LiteralType -> Either Errors.Error Syntax.NamedType +encodeLiteralType cx lt = + case lt of + Model.LiteralTypeBoolean -> Right (Syntax.NamedType (Syntax.Name "Boolean")) + Model.LiteralTypeFloat v0 -> case v0 of + Model.FloatTypeFloat64 -> Right (Syntax.NamedType (Syntax.Name "Float")) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected 64-bit float type, found: " (PrintModel.floatType v0)))) + Model.LiteralTypeInteger v0 -> case v0 of + Model.IntegerTypeInt32 -> Right (Syntax.NamedType (Syntax.Name "Int")) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected 32-bit signed integer type, found: " (PrintModel.integerType v0)))) + Model.LiteralTypeString -> Right (Syntax.NamedType (Syntax.Name "String")) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible literal type, found: " (PrintModel.literalType lt)))) + +-- | Encode a named type to a GraphQL type definition. +encodeNamedType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.Name -> Model.Type -> Either Errors.Error Syntax.TypeDefinition +encodeNamedType cx g prefixes name typ = + case (Strip.deannotateType typ) of + Model.TypeRecord v0 -> Eithers.bind (Eithers.mapList (\f -> encodeFieldType cx g prefixes f) v0) (\gfields -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionObject (Syntax.ObjectTypeDefinition { + Syntax.objectTypeDefinitionDescription = desc, + Syntax.objectTypeDefinitionName = (encodeTypeName prefixes name), + Syntax.objectTypeDefinitionImplementsInterfaces = Nothing, + Syntax.objectTypeDefinitionDirectives = Nothing, + Syntax.objectTypeDefinitionFieldsDefinition = (Just (Syntax.FieldsDefinition gfields))})))) + Model.TypeUnion v0 -> Logic.ifElse (Predicates.isEnumRowType v0) (Eithers.bind (Eithers.mapList (\f -> encodeEnumFieldType cx g f) v0) (\values -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionEnum (Syntax.EnumTypeDefinition { + Syntax.enumTypeDefinitionDescription = desc, + Syntax.enumTypeDefinitionName = (encodeTypeName prefixes name), + Syntax.enumTypeDefinitionDirectives = Nothing, + Syntax.enumTypeDefinitionEnumValuesDefinition = (Just (Syntax.EnumValuesDefinition values))}))))) (Eithers.bind (Eithers.mapList (\f -> encodeUnionFieldType cx g prefixes f) v0) (\gfields -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionObject (Syntax.ObjectTypeDefinition { + Syntax.objectTypeDefinitionDescription = desc, + Syntax.objectTypeDefinitionName = (encodeTypeName prefixes name), + Syntax.objectTypeDefinitionImplementsInterfaces = Nothing, + Syntax.objectTypeDefinitionDirectives = Nothing, + Syntax.objectTypeDefinitionFieldsDefinition = (Just (Syntax.FieldsDefinition gfields))}))))) + Model.TypeEither v0 -> encodeNamedType cx g prefixes name (Model.TypeRecord [ + Model.FieldType { + Model.fieldTypeName = (Model.Name "left"), + Model.fieldTypeType = (Model.TypeOptional (Model.eitherTypeLeft v0))}, + Model.FieldType { + Model.fieldTypeName = (Model.Name "right"), + Model.fieldTypeType = (Model.TypeOptional (Model.eitherTypeRight v0))}]) + Model.TypePair v0 -> encodeNamedType cx g prefixes name (Model.TypeRecord [ + Model.FieldType { + Model.fieldTypeName = (Model.Name "first"), + Model.fieldTypeType = (Model.pairTypeFirst v0)}, + Model.FieldType { + Model.fieldTypeName = (Model.Name "second"), + Model.fieldTypeType = (Model.pairTypeSecond v0)}]) + Model.TypeList v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Model.TypeList v0)) + Model.TypeSet v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Model.TypeList v0)) + Model.TypeMap v0 -> encodeNamedType cx g prefixes name (Model.TypeRecord [ + Model.FieldType { + Model.fieldTypeName = (Model.Name "key"), + Model.fieldTypeType = (Model.mapTypeKeys v0)}, + Model.FieldType { + Model.fieldTypeName = (Model.Name "value"), + Model.fieldTypeType = (Model.mapTypeValues v0)}]) + Model.TypeLiteral v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Model.TypeLiteral v0)) + Model.TypeVariable v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Model.TypeVariable v0)) + Model.TypeWrap v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord v0) + Model.TypeUnit -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Model.TypeLiteral Model.LiteralTypeBoolean)) + Model.TypeForall v0 -> encodeNamedType cx g prefixes name (Model.forallTypeBody v0) + Model.TypeApplication v0 -> encodeNamedType cx g prefixes name (Model.applicationTypeFunction v0) + Model.TypeFunction v0 -> encodeNamedType cx g prefixes name (Model.TypeRecord [ + Model.FieldType { + Model.fieldTypeName = (Model.Name "domain"), + Model.fieldTypeType = (Model.functionTypeDomain v0)}, + Model.FieldType { + Model.fieldTypeName = (Model.Name "codomain"), + Model.fieldTypeType = (Model.functionTypeCodomain v0)}]) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected record or union type, found: " (PrintModel.type_ typ)))) + +-- | Encode a Hydra type as a GraphQL type reference +encodeType :: t0 -> t1 -> M.Map Packaging.ModuleName String -> Model.Type -> Either Errors.Error Syntax.Type +encodeType cx g prefixes typ = + case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> case (Strip.deannotateType v0) of + Model.TypeList v1 -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes v1) + Model.TypeSet v1 -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes v1) + Model.TypeMap v1 -> Eithers.bind (checkMapKeyRepresentable (Model.mapTypeKeys v1)) (\_ -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes (Model.mapTypeValues v1))) + Model.TypeLiteral v1 -> Eithers.map (\nt -> Syntax.TypeNamed nt) (encodeLiteralType cx v1) + Model.TypePair _ -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes (Model.Name "hydra.core.util.Pair")))) + Model.TypeEither _ -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes (Model.Name "hydra.core.util.Either")))) + Model.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) + Model.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) + Model.TypeWrap v1 -> encodeType cx g prefixes (Model.TypeOptional v1) + Model.TypeVariable v1 -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes v1))) + Model.TypeForall v1 -> encodeType cx g prefixes (Model.TypeOptional (Model.forallTypeBody v1)) + Model.TypeApplication v1 -> encodeType cx g prefixes (Model.TypeOptional (Model.applicationTypeFunction v1)) + Model.TypeFunction _ -> Right (Syntax.TypeNamed (Syntax.NamedType (Syntax.Name "String"))) + Model.TypeUnit -> Right (Syntax.TypeNamed (Syntax.NamedType (Syntax.Name "Boolean"))) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible type, found: " (PrintModel.type_ v0)))) + Model.TypeList v0 -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes v0) + Model.TypeSet v0 -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes v0) + Model.TypeMap v0 -> Eithers.bind (checkMapKeyRepresentable (Model.mapTypeKeys v0)) (\_ -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes (Model.mapTypeValues v0))) + Model.TypeLiteral v0 -> Eithers.map (\nt -> Syntax.TypeNonNull (Syntax.NonNullTypeNamed nt)) (encodeLiteralType cx v0) + Model.TypePair _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes (Model.Name "hydra.core.util.Pair"))))) + Model.TypeEither _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes (Model.Name "hydra.core.util.Either"))))) + Model.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) + Model.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) + Model.TypeVariable v0 -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes v0)))) + Model.TypeWrap v0 -> encodeType cx g prefixes v0 + Model.TypeForall v0 -> encodeType cx g prefixes (Model.forallTypeBody v0) + Model.TypeApplication v0 -> encodeType cx g prefixes (Model.applicationTypeFunction v0) + Model.TypeFunction _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (Syntax.Name "String")))) + Model.TypeUnit -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (Syntax.Name "Boolean")))) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible type, found: " (PrintModel.type_ typ)))) + +-- | Encode a TypeDefinition to a GraphQL TypeDefinition +encodeTypeDefinition :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Packaging.TypeDefinition -> Either Errors.Error Syntax.TypeDefinition +encodeTypeDefinition cx g prefixes tdef = + encodeNamedType cx g prefixes (Packaging.typeDefinitionName tdef) (Model.typeSchemeBody (Packaging.typeDefinitionBody tdef)) + +-- | Encode a Hydra Name as a GraphQL Name with namespace prefix +encodeTypeName :: M.Map Packaging.ModuleName String -> Model.Name -> Syntax.Name +encodeTypeName prefixes name = + + let qualName = Names.qualifyName name + local = Util.qualifiedNameLocal qualName + mns = Util.qualifiedNameModuleName qualName + prefix = Optionals.match mns "" (\ns_ -> Optionals.match (Maps.lookup ns_ prefixes) "" (\p -> p)) + in (Syntax.Name (Strings.concat2 prefix (sanitize local))) + +-- | Encode a union variant field type to a nullable GraphQL FieldDefinition. Unit-typed variants become Boolean fields; data-carrying variants use their actual type, made nullable. +encodeUnionFieldType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.FieldType -> Either Errors.Error Syntax.FieldDefinition +encodeUnionFieldType cx g prefixes ft = + + let innerType = Model.fieldTypeType ft + isUnit = Predicates.isUnitType (Strip.deannotateType innerType) + effectiveType = + Logic.ifElse isUnit (Model.TypeOptional (Model.TypeLiteral Model.LiteralTypeBoolean)) (Model.TypeOptional innerType) + in (Eithers.bind (encodeType cx g prefixes effectiveType) (\gtype -> Eithers.bind (descriptionFromType cx g innerType) (\desc -> Right (Syntax.FieldDefinition { + Syntax.fieldDefinitionDescription = desc, + Syntax.fieldDefinitionName = (encodeFieldName (Model.fieldTypeName ft)), + Syntax.fieldDefinitionArgumentsDefinition = Nothing, + Syntax.fieldDefinitionType = gtype, + Syntax.fieldDefinitionDirectives = Nothing})))) + +-- | Top-level entry point: convert a module to GraphQL schema files. +moduleToGraphql :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String) +moduleToGraphql mod defs cx g = + + let partitioned = Environment.partitionDefinitions defs + typeDefs = Pairs.first partitioned + prefixes = + (\modNs -> \tdefs -> + let namespaces = Lists.distinct (Optionals.givens (Lists.map (\td -> Names.moduleNameOf (Packaging.typeDefinitionName td)) tdefs)) + in (Maps.fromList (Lists.map (\ns_ -> ( + ns_, + (Logic.ifElse (Equality.equal ns_ modNs) "" (Strings.concat2 (Formatting.sanitizeWithUnderscores Sets.empty (Packaging.unModuleName ns_)) "_")))) namespaces))) (Packaging.moduleName mod) typeDefs + filePath = Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "graphql") (Packaging.moduleName mod) + in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g prefixes td) typeDefs) (\gtdefs -> Right (Maps.fromList (Lists.singleton ( + filePath, + (Serialization.printExpr (Serialization.parenthesize (Serde.documentToExpr (Syntax.Document (Lists.map (\gtdef -> Syntax.DefinitionTypeSystem (Syntax.TypeSystemDefinitionOrExtensionDefinition (Syntax.TypeSystemDefinitionType gtdef))) gtdefs)))))))))) + +-- | Sanitize a string for use as a GraphQL identifier +sanitize :: String -> String +sanitize s = Formatting.sanitizeWithUnderscores Language.graphqlReservedWords s diff --git a/src/main/haskell/Hydra/Ext/Graphql/Language.hs b/src/main/haskell/Hydra/Ext/Graphql/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Graphql/Language.hs @@ -0,0 +1,121 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints and reserved words for GraphQL + +module Hydra.Ext.Graphql.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | Language constraints for GraphQL +graphqlLanguage :: Coders.Language +graphqlLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.graphql"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "graphql")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = Sets.fromList [ + Model.FloatTypeFloat64] + integerTypes = Sets.fromList [ + Model.IntegerTypeInt32] + termVariants = + Sets.fromList [ + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantOptional, + Variants.TermVariantRecord, + Variants.TermVariantInject] + typeVariants = + Sets.fromList [ + Variants.TypeVariantApplication, + Variants.TypeVariantEither, + Variants.TypeVariantForall, + Variants.TypeVariantFunction, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantPair, + Variants.TypeVariantSet, + Variants.TypeVariantUnit, + Variants.TypeVariantWrap, + Variants.TypeVariantOptional, + Variants.TypeVariantRecord, + Variants.TypeVariantUnion, + Variants.TypeVariantVariable] + typePredicate = + \typ -> case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> case (Strip.deannotateType v0) of + Model.TypeOptional _ -> False + _ -> True + _ -> True + +-- | A set of reserved words in GraphQL +graphqlReservedWords :: S.Set String +graphqlReservedWords = + Sets.fromList [ + "true", + "false"] diff --git a/src/main/haskell/Hydra/Ext/Graphql/Serde.hs b/src/main/haskell/Hydra/Ext/Graphql/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Graphql/Serde.hs @@ -0,0 +1,189 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Serialization functions for converting GraphQL AST to abstract expressions + +module Hydra.Ext.Graphql.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Graphql.Syntax as Syntax +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Convert a GraphQL definition to an expression +definitionToExpr :: Syntax.Definition -> Ast.Expr +definitionToExpr def = + case def of + Syntax.DefinitionExecutable _ -> Serialization.cst "Unsupported: executable definition" + Syntax.DefinitionTypeSystem v0 -> typeSystemDefinitionOrExtensionToExpr v0 + +-- | Convert a GraphQL description to a triple-quoted comment +descriptionToExpr :: Syntax.Description -> Ast.Expr +descriptionToExpr desc = + + let delim = Serialization.cst "\"\"\"" + text = Syntax.unStringValue (Syntax.unDescription desc) + in (Serialization.newlineSep [ + delim, + (Serialization.cst text), + delim]) + +-- | Convert a GraphQL document to an expression +documentToExpr :: Syntax.Document -> Ast.Expr +documentToExpr d = Serialization.doubleNewlineSep (Lists.map definitionToExpr (Syntax.unDocument d)) + +-- | Convert a GraphQL enum type definition to an expression +enumTypeDefinitionToExpr :: Syntax.EnumTypeDefinition -> Ast.Expr +enumTypeDefinitionToExpr def = + + let desc = Syntax.enumTypeDefinitionDescription def + name = Syntax.enumTypeDefinitionName def + values = Syntax.enumTypeDefinitionEnumValuesDefinition def + valuesExpr = Optionals.match values [] (\vs -> Lists.map enumValueDefinitionToExpr (Syntax.unEnumValuesDefinition vs)) + in (withDescription desc (Serialization.spaceSep [ + Serialization.cst "enum", + (nameToExpr name), + (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle valuesExpr)])) + +-- | Convert a GraphQL enum value definition to an expression +enumValueDefinitionToExpr :: Syntax.EnumValueDefinition -> Ast.Expr +enumValueDefinitionToExpr def = + + let desc = Syntax.enumValueDefinitionDescription def + ev = Syntax.enumValueDefinitionEnumValue def + in (withDescription desc (enumValueToExpr ev)) + +-- | Convert a GraphQL enum value to an expression +enumValueToExpr :: Syntax.EnumValue -> Ast.Expr +enumValueToExpr ev = nameToExpr (Syntax.unEnumValue ev) + +-- | Convert a GraphQL field definition to an expression +fieldDefinitionToExpr :: Syntax.FieldDefinition -> Ast.Expr +fieldDefinitionToExpr def = + + let desc = Syntax.fieldDefinitionDescription def + name = Syntax.fieldDefinitionName def + typ = Syntax.fieldDefinitionType def + namePart = + Serialization.noSep [ + nameToExpr name, + (Serialization.cst ":")] + typePart = typeToExpr typ + in (withDescription desc (Serialization.spaceSep [ + namePart, + typePart])) + +-- | Convert a GraphQL list type to an expression +listTypeToExpr :: Syntax.ListType -> Ast.Expr +listTypeToExpr lt = + Serialization.noSep [ + Serialization.cst "[", + (typeToExpr (Syntax.unListType lt)), + (Serialization.cst "]")] + +-- | Convert a GraphQL name to an expression +nameToExpr :: Syntax.Name -> Ast.Expr +nameToExpr n = Serialization.cst (Syntax.unName n) + +-- | Convert a GraphQL named type to an expression +namedTypeToExpr :: Syntax.NamedType -> Ast.Expr +namedTypeToExpr nt = nameToExpr (Syntax.unNamedType nt) + +-- | Convert a GraphQL non-null type to an expression +nonNullTypeToExpr :: Syntax.NonNullType -> Ast.Expr +nonNullTypeToExpr nnt = + + let typeExpr = + case nnt of + Syntax.NonNullTypeNamed v0 -> namedTypeToExpr v0 + Syntax.NonNullTypeList v0 -> listTypeToExpr v0 + in (Serialization.noSep [ + typeExpr, + (Serialization.cst "!")]) + +-- | Convert a GraphQL object type definition to an expression +objectTypeDefinitionToExpr :: Syntax.ObjectTypeDefinition -> Ast.Expr +objectTypeDefinitionToExpr def = + + let desc = Syntax.objectTypeDefinitionDescription def + name = Syntax.objectTypeDefinitionName def + fields = Syntax.objectTypeDefinitionFieldsDefinition def + fieldsExpr = Optionals.match fields [] (\fs -> Lists.map fieldDefinitionToExpr (Syntax.unFieldsDefinition fs)) + in (withDescription desc (Serialization.spaceSep [ + Serialization.cst "type", + (nameToExpr name), + (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle fieldsExpr)])) + +-- | Convert a GraphQL type definition to an expression +typeDefinitionToExpr :: Syntax.TypeDefinition -> Ast.Expr +typeDefinitionToExpr def = + case def of + Syntax.TypeDefinitionScalar _ -> Serialization.cst "Unsupported: scalar type definition" + Syntax.TypeDefinitionObject v0 -> objectTypeDefinitionToExpr v0 + Syntax.TypeDefinitionInterface _ -> Serialization.cst "Unsupported: interface type definition" + Syntax.TypeDefinitionUnion _ -> Serialization.cst "Unsupported: union type definition" + Syntax.TypeDefinitionEnum v0 -> enumTypeDefinitionToExpr v0 + Syntax.TypeDefinitionInputObject _ -> Serialization.cst "Unsupported: input object type definition" + +-- | Convert a GraphQL type system definition or extension to an expression +typeSystemDefinitionOrExtensionToExpr :: Syntax.TypeSystemDefinitionOrExtension -> Ast.Expr +typeSystemDefinitionOrExtensionToExpr de = + case de of + Syntax.TypeSystemDefinitionOrExtensionDefinition v0 -> typeSystemDefinitionToExpr v0 + Syntax.TypeSystemDefinitionOrExtensionExtension _ -> Serialization.cst "Unsupported: type system extension" + +-- | Convert a GraphQL type system definition to an expression +typeSystemDefinitionToExpr :: Syntax.TypeSystemDefinition -> Ast.Expr +typeSystemDefinitionToExpr def = + case def of + Syntax.TypeSystemDefinitionSchema _ -> Serialization.cst "Unsupported: schema definition" + Syntax.TypeSystemDefinitionType v0 -> typeDefinitionToExpr v0 + Syntax.TypeSystemDefinitionDirective _ -> Serialization.cst "Unsupported: directive definition" + +-- | Convert a GraphQL type to an expression +typeToExpr :: Syntax.Type -> Ast.Expr +typeToExpr typ = + case typ of + Syntax.TypeNamed v0 -> namedTypeToExpr v0 + Syntax.TypeList v0 -> listTypeToExpr v0 + Syntax.TypeNonNull v0 -> nonNullTypeToExpr v0 + +-- | Prepend an optional description to an expression +withDescription :: Maybe Syntax.Description -> Ast.Expr -> Ast.Expr +withDescription mdesc expr = + Serialization.newlineSep (Optionals.givens [ + Optionals.map descriptionToExpr mdesc, + (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Ext/Graphql/Syntax.hs b/src/main/haskell/Hydra/Ext/Graphql/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Graphql/Syntax.hs @@ -0,0 +1,1397 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A GraphQL model. Based on the (extended) BNF at: +-- | https://spec.graphql.org/draft/#sec-Appendix-Grammar-Summary + +module Hydra.Ext.Graphql.Syntax where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A GraphQL field alias, immediately followed by a colon. +data Alias = + AliasName Name | + AliasColon + deriving (Eq, Ord, Read, Show) + +_Alias = Model.Name "hydra.ext.graphql.syntax.Alias" + +_Alias_Name = Model.Name "Name" + +_Alias_Colon = Model.Name "Colon" + +-- | A single GraphQL argument, consisting of a name and a value. +data Argument = + Argument { + argumentName :: Name, + argumentValue :: Value} + deriving (Eq, Ord, Read, Show) + +_Argument = Model.Name "hydra.ext.graphql.syntax.Argument" + +_Argument_Name = Model.Name "Name" + +_Argument_Value = Model.Name "Value" + +-- | A parenthesized list of GraphQL arguments. +newtype Arguments = + Arguments { + unArguments :: [Argument]} + deriving (Eq, Ord, Read, Show) + +_Arguments = Model.Name "hydra.ext.graphql.syntax.Arguments" + +-- | A parenthesized list of GraphQL input value definitions for a field's arguments. +newtype ArgumentsDefinition = + ArgumentsDefinition { + unArgumentsDefinition :: [InputValueDefinition]} + deriving (Eq, Ord, Read, Show) + +_ArgumentsDefinition = Model.Name "hydra.ext.graphql.syntax.ArgumentsDefinition" + +-- | A GraphQL boolean literal, either true or false. +data BooleanValue = + BooleanValueTrue | + BooleanValueFalse + deriving (Eq, Ord, Read, Show) + +_BooleanValue = Model.Name "hydra.ext.graphql.syntax.BooleanValue" + +_BooleanValue_True = Model.Name "True" + +_BooleanValue_False = Model.Name "False" + +-- | A default value for a GraphQL variable or input field, introduced by an equals sign. +newtype DefaultValue = + DefaultValue { + unDefaultValue :: Value} + deriving (Eq, Ord, Read, Show) + +_DefaultValue = Model.Name "hydra.ext.graphql.syntax.DefaultValue" + +-- | A top-level GraphQL definition, either executable or part of the type system. +data Definition = + DefinitionExecutable ExecutableDefinition | + DefinitionTypeSystem TypeSystemDefinitionOrExtension + deriving (Eq, Ord, Read, Show) + +_Definition = Model.Name "hydra.ext.graphql.syntax.Definition" + +_Definition_executable = Model.Name "executable" + +_Definition_typeSystem = Model.Name "typeSystem" + +-- | An optional string description preceding a GraphQL type system definition. +newtype Description = + Description { + unDescription :: StringValue} + deriving (Eq, Ord, Read, Show) + +_Description = Model.Name "hydra.ext.graphql.syntax.Description" + +-- | A single GraphQL directive, consisting of a name and optional arguments. +data Directive = + Directive { + directiveName :: Name, + directiveArguments :: (Maybe Arguments)} + deriving (Eq, Ord, Read, Show) + +_Directive = Model.Name "hydra.ext.graphql.syntax.Directive" + +_Directive_Name = Model.Name "Name" + +_Directive_Arguments = Model.Name "Arguments" + +-- | A GraphQL directive definition, giving its name, arguments, repeatability, and locations. +data DirectiveDefinition = + DirectiveDefinition { + directiveDefinitionDescription :: (Maybe Description), + directiveDefinitionName :: Name, + directiveDefinitionArgumentsDefinition :: (Maybe ArgumentsDefinition), + directiveDefinitionRepeatable :: (Maybe ()), + directiveDefinitionDirectiveLocations :: DirectiveLocations} + deriving (Eq, Ord, Read, Show) + +_DirectiveDefinition = Model.Name "hydra.ext.graphql.syntax.DirectiveDefinition" + +_DirectiveDefinition_Description = Model.Name "Description" + +_DirectiveDefinition_Name = Model.Name "Name" + +_DirectiveDefinition_ArgumentsDefinition = Model.Name "ArgumentsDefinition" + +_DirectiveDefinition_Repeatable = Model.Name "Repeatable" + +_DirectiveDefinition_DirectiveLocations = Model.Name "DirectiveLocations" + +-- | A location at which a GraphQL directive may be applied, either executable or type-system. +data DirectiveLocation = + DirectiveLocationExecutable ExecutableDirectiveLocation | + DirectiveLocationTypeSystem TypeSystemDirectiveLocation + deriving (Eq, Ord, Read, Show) + +_DirectiveLocation = Model.Name "hydra.ext.graphql.syntax.DirectiveLocation" + +_DirectiveLocation_executable = Model.Name "executable" + +_DirectiveLocation_typeSystem = Model.Name "typeSystem" + +-- | A pipe-separated list of GraphQL directive locations. +data DirectiveLocations = + DirectiveLocationsSeq DirectiveLocationsSequence | + DirectiveLocationsSeq2 DirectiveLocationsSequence2 + deriving (Eq, Ord, Read, Show) + +_DirectiveLocations = Model.Name "hydra.ext.graphql.syntax.DirectiveLocations" + +_DirectiveLocations_seq = Model.Name "seq" + +_DirectiveLocations_seq2 = Model.Name "seq2" + +-- | A non-empty DirectiveLocations sequence with a leading list of locations. +data DirectiveLocationsSequence = + DirectiveLocationsSequence { + directiveLocationsSequenceDirectiveLocations :: DirectiveLocations, + directiveLocationsSequenceDirectiveLocation :: DirectiveLocation} + deriving (Eq, Ord, Read, Show) + +_DirectiveLocationsSequence = Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence" + +_DirectiveLocationsSequence_DirectiveLocations = Model.Name "DirectiveLocations" + +_DirectiveLocationsSequence_DirectiveLocation = Model.Name "DirectiveLocation" + +-- | The base case of a DirectiveLocations sequence: a single, optionally pipe-prefixed location. +data DirectiveLocationsSequence2 = + DirectiveLocationsSequence2 { + directiveLocationsSequence2Or :: (Maybe ()), + directiveLocationsSequence2DirectiveLocation :: DirectiveLocation} + deriving (Eq, Ord, Read, Show) + +_DirectiveLocationsSequence2 = Model.Name "hydra.ext.graphql.syntax.DirectiveLocationsSequence2" + +_DirectiveLocationsSequence2_Or = Model.Name "Or" + +_DirectiveLocationsSequence2_DirectiveLocation = Model.Name "DirectiveLocation" + +-- | A list of GraphQL directives applied to a definition or selection. +newtype Directives = + Directives { + unDirectives :: [Directive]} + deriving (Eq, Ord, Read, Show) + +_Directives = Model.Name "hydra.ext.graphql.syntax.Directives" + +-- | A GraphQL document, consisting of a list of definitions. +newtype Document = + Document { + unDocument :: [Definition]} + deriving (Eq, Ord, Read, Show) + +_Document = Model.Name "hydra.ext.graphql.syntax.Document" + +-- | A GraphQL enum type definition, giving its name, directives, and enum values. +data EnumTypeDefinition = + EnumTypeDefinition { + enumTypeDefinitionDescription :: (Maybe Description), + enumTypeDefinitionName :: Name, + enumTypeDefinitionDirectives :: (Maybe Directives), + enumTypeDefinitionEnumValuesDefinition :: (Maybe EnumValuesDefinition)} + deriving (Eq, Ord, Read, Show) + +_EnumTypeDefinition = Model.Name "hydra.ext.graphql.syntax.EnumTypeDefinition" + +_EnumTypeDefinition_Description = Model.Name "Description" + +_EnumTypeDefinition_Name = Model.Name "Name" + +_EnumTypeDefinition_Directives = Model.Name "Directives" + +_EnumTypeDefinition_EnumValuesDefinition = Model.Name "EnumValuesDefinition" + +-- | An extension of a GraphQL enum type, either adding enum values or only directives. +data EnumTypeExtension = + EnumTypeExtensionSeq EnumTypeExtensionSequence | + EnumTypeExtensionSeq2 EnumTypeExtensionSequence2 + deriving (Eq, Ord, Read, Show) + +_EnumTypeExtension = Model.Name "hydra.ext.graphql.syntax.EnumTypeExtension" + +_EnumTypeExtension_seq = Model.Name "seq" + +_EnumTypeExtension_seq2 = Model.Name "seq2" + +-- | An enum type extension that adds new enum values, with optional directives. +data EnumTypeExtensionSequence = + EnumTypeExtensionSequence { + enumTypeExtensionSequenceName :: Name, + enumTypeExtensionSequenceDirectives :: (Maybe Directives), + enumTypeExtensionSequenceEnumValuesDefinition :: EnumValuesDefinition} + deriving (Eq, Ord, Read, Show) + +_EnumTypeExtensionSequence = Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence" + +_EnumTypeExtensionSequence_Name = Model.Name "Name" + +_EnumTypeExtensionSequence_Directives = Model.Name "Directives" + +_EnumTypeExtensionSequence_EnumValuesDefinition = Model.Name "EnumValuesDefinition" + +-- | An enum type extension consisting of directives only, with no new enum values. +data EnumTypeExtensionSequence2 = + EnumTypeExtensionSequence2 { + enumTypeExtensionSequence2Name :: Name, + enumTypeExtensionSequence2Directives :: Directives} + deriving (Eq, Ord, Read, Show) + +_EnumTypeExtensionSequence2 = Model.Name "hydra.ext.graphql.syntax.EnumTypeExtensionSequence2" + +_EnumTypeExtensionSequence2_Name = Model.Name "Name" + +_EnumTypeExtensionSequence2_Directives = Model.Name "Directives" + +-- | A GraphQL enum value, represented as a name (excluding true, false, and null). +newtype EnumValue = + EnumValue { + unEnumValue :: Name} + deriving (Eq, Ord, Read, Show) + +_EnumValue = Model.Name "hydra.ext.graphql.syntax.EnumValue" + +-- | A single value definition within a GraphQL enum type, with optional description and directives. +data EnumValueDefinition = + EnumValueDefinition { + enumValueDefinitionDescription :: (Maybe Description), + enumValueDefinitionEnumValue :: EnumValue, + enumValueDefinitionDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_EnumValueDefinition = Model.Name "hydra.ext.graphql.syntax.EnumValueDefinition" + +_EnumValueDefinition_Description = Model.Name "Description" + +_EnumValueDefinition_EnumValue = Model.Name "EnumValue" + +_EnumValueDefinition_Directives = Model.Name "Directives" + +-- | The braced list of enum value definitions in a GraphQL enum type. +newtype EnumValuesDefinition = + EnumValuesDefinition { + unEnumValuesDefinition :: [EnumValueDefinition]} + deriving (Eq, Ord, Read, Show) + +_EnumValuesDefinition = Model.Name "hydra.ext.graphql.syntax.EnumValuesDefinition" + +-- | A GraphQL executable definition, either an operation or a fragment definition. +data ExecutableDefinition = + ExecutableDefinitionOperation OperationDefinition | + ExecutableDefinitionFragment FragmentDefinition + deriving (Eq, Ord, Read, Show) + +_ExecutableDefinition = Model.Name "hydra.ext.graphql.syntax.ExecutableDefinition" + +_ExecutableDefinition_operation = Model.Name "operation" + +_ExecutableDefinition_fragment = Model.Name "fragment" + +-- | A directive location valid on GraphQL executable definitions (queries, fields, fragments, etc.). +data ExecutableDirectiveLocation = + ExecutableDirectiveLocationQUERY | + ExecutableDirectiveLocationMUTATION | + ExecutableDirectiveLocationSUBSCRIPTION | + ExecutableDirectiveLocationFIELD | + ExecutableDirectiveLocationFRAGMENT_DEFINITION | + ExecutableDirectiveLocationFRAGMENT_SPREAD | + ExecutableDirectiveLocationINLINE_FRAGMENT | + ExecutableDirectiveLocationVARIABLE_DEFINITION + deriving (Eq, Ord, Read, Show) + +_ExecutableDirectiveLocation = Model.Name "hydra.ext.graphql.syntax.ExecutableDirectiveLocation" + +_ExecutableDirectiveLocation_QUERY = Model.Name "QUERY" + +_ExecutableDirectiveLocation_MUTATION = Model.Name "MUTATION" + +_ExecutableDirectiveLocation_SUBSCRIPTION = Model.Name "SUBSCRIPTION" + +_ExecutableDirectiveLocation_FIELD = Model.Name "FIELD" + +_ExecutableDirectiveLocation_FRAGMENT_DEFINITION = Model.Name "FRAGMENT_DEFINITION" + +_ExecutableDirectiveLocation_FRAGMENT_SPREAD = Model.Name "FRAGMENT_SPREAD" + +_ExecutableDirectiveLocation_INLINE_FRAGMENT = Model.Name "INLINE_FRAGMENT" + +_ExecutableDirectiveLocation_VARIABLE_DEFINITION = Model.Name "VARIABLE_DEFINITION" + +-- | A GraphQL document consisting only of executable definitions. +newtype ExecutableDocument = + ExecutableDocument { + unExecutableDocument :: [ExecutableDefinition]} + deriving (Eq, Ord, Read, Show) + +_ExecutableDocument = Model.Name "hydra.ext.graphql.syntax.ExecutableDocument" + +-- | A GraphQL field selection, with optional alias, arguments, directives, and sub-selection set. +data Field = + Field { + fieldAlias :: (Maybe Alias), + fieldName :: Name, + fieldArguments :: (Maybe Arguments), + fieldDirectives :: (Maybe Directives), + fieldSelectionSet :: (Maybe SelectionSet)} + deriving (Eq, Ord, Read, Show) + +_Field = Model.Name "hydra.ext.graphql.syntax.Field" + +_Field_Alias = Model.Name "Alias" + +_Field_Name = Model.Name "Name" + +_Field_Arguments = Model.Name "Arguments" + +_Field_Directives = Model.Name "Directives" + +_Field_SelectionSet = Model.Name "SelectionSet" + +-- | A field definition within a GraphQL object or interface type. +data FieldDefinition = + FieldDefinition { + fieldDefinitionDescription :: (Maybe Description), + fieldDefinitionName :: Name, + fieldDefinitionArgumentsDefinition :: (Maybe ArgumentsDefinition), + fieldDefinitionType :: Type, + fieldDefinitionDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_FieldDefinition = Model.Name "hydra.ext.graphql.syntax.FieldDefinition" + +_FieldDefinition_Description = Model.Name "Description" + +_FieldDefinition_Name = Model.Name "Name" + +_FieldDefinition_ArgumentsDefinition = Model.Name "ArgumentsDefinition" + +_FieldDefinition_Type = Model.Name "Type" + +_FieldDefinition_Directives = Model.Name "Directives" + +-- | The braced list of field definitions in a GraphQL object or interface type. +newtype FieldsDefinition = + FieldsDefinition { + unFieldsDefinition :: [FieldDefinition]} + deriving (Eq, Ord, Read, Show) + +_FieldsDefinition = Model.Name "hydra.ext.graphql.syntax.FieldsDefinition" + +-- | A GraphQL floating-point literal. +newtype FloatValue = + FloatValue { + unFloatValue :: String} + deriving (Eq, Ord, Read, Show) + +_FloatValue = Model.Name "hydra.ext.graphql.syntax.FloatValue" + +-- | A GraphQL fragment definition, naming a type condition and a selection set. +data FragmentDefinition = + FragmentDefinition { + fragmentDefinitionFragmentName :: FragmentName, + fragmentDefinitionTypeCondition :: TypeCondition, + fragmentDefinitionDirectives :: (Maybe Directives), + fragmentDefinitionSelectionSet :: SelectionSet} + deriving (Eq, Ord, Read, Show) + +_FragmentDefinition = Model.Name "hydra.ext.graphql.syntax.FragmentDefinition" + +_FragmentDefinition_FragmentName = Model.Name "FragmentName" + +_FragmentDefinition_TypeCondition = Model.Name "TypeCondition" + +_FragmentDefinition_Directives = Model.Name "Directives" + +_FragmentDefinition_SelectionSet = Model.Name "SelectionSet" + +-- | The name of a GraphQL fragment (any name other than "on"). +newtype FragmentName = + FragmentName { + unFragmentName :: Name} + deriving (Eq, Ord, Read, Show) + +_FragmentName = Model.Name "hydra.ext.graphql.syntax.FragmentName" + +-- | A GraphQL fragment spread, referencing a named fragment with optional directives. +data FragmentSpread = + FragmentSpread { + fragmentSpreadFragmentName :: FragmentName, + fragmentSpreadDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_FragmentSpread = Model.Name "hydra.ext.graphql.syntax.FragmentSpread" + +_FragmentSpread_FragmentName = Model.Name "FragmentName" + +_FragmentSpread_Directives = Model.Name "Directives" + +-- | A clause declaring the interfaces implemented by a GraphQL object or interface type. +data ImplementsInterfaces = + ImplementsInterfacesSeq ImplementsInterfacesSequence | + ImplementsInterfacesSeq2 ImplementsInterfacesSequence2 + deriving (Eq, Ord, Read, Show) + +_ImplementsInterfaces = Model.Name "hydra.ext.graphql.syntax.ImplementsInterfaces" + +_ImplementsInterfaces_seq = Model.Name "seq" + +_ImplementsInterfaces_seq2 = Model.Name "seq2" + +-- | A non-empty ImplementsInterfaces list with a leading list of interfaces. +data ImplementsInterfacesSequence = + ImplementsInterfacesSequence { + implementsInterfacesSequenceImplementsInterfaces :: ImplementsInterfaces, + implementsInterfacesSequenceNamedType :: NamedType} + deriving (Eq, Ord, Read, Show) + +_ImplementsInterfacesSequence = Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence" + +_ImplementsInterfacesSequence_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_ImplementsInterfacesSequence_NamedType = Model.Name "NamedType" + +-- | The base case of an ImplementsInterfaces list: a single, optionally ampersand-prefixed interface. +data ImplementsInterfacesSequence2 = + ImplementsInterfacesSequence2 { + implementsInterfacesSequence2Amp :: (Maybe ()), + implementsInterfacesSequence2NamedType :: NamedType} + deriving (Eq, Ord, Read, Show) + +_ImplementsInterfacesSequence2 = Model.Name "hydra.ext.graphql.syntax.ImplementsInterfacesSequence2" + +_ImplementsInterfacesSequence2_Amp = Model.Name "Amp" + +_ImplementsInterfacesSequence2_NamedType = Model.Name "NamedType" + +-- | A GraphQL inline fragment, with optional type condition, directives, and a selection set. +data InlineFragment = + InlineFragment { + inlineFragmentTypeCondition :: (Maybe TypeCondition), + inlineFragmentDirectives :: (Maybe Directives), + inlineFragmentSelectionSet :: SelectionSet} + deriving (Eq, Ord, Read, Show) + +_InlineFragment = Model.Name "hydra.ext.graphql.syntax.InlineFragment" + +_InlineFragment_TypeCondition = Model.Name "TypeCondition" + +_InlineFragment_Directives = Model.Name "Directives" + +_InlineFragment_SelectionSet = Model.Name "SelectionSet" + +-- | The braced list of input field definitions in a GraphQL input object type. +newtype InputFieldsDefinition = + InputFieldsDefinition { + unInputFieldsDefinition :: [InputValueDefinition]} + deriving (Eq, Ord, Read, Show) + +_InputFieldsDefinition = Model.Name "hydra.ext.graphql.syntax.InputFieldsDefinition" + +-- | A GraphQL input object type definition, either with or without input fields. +data InputObjectTypeDefinition = + InputObjectTypeDefinitionSeq InputObjectTypeDefinitionSequence | + InputObjectTypeDefinitionSeq2 InputObjectTypeDefinitionSequence2 + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeDefinition = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinition" + +_InputObjectTypeDefinition_seq = Model.Name "seq" + +_InputObjectTypeDefinition_seq2 = Model.Name "seq2" + +-- | An input object type definition that includes an input fields definition. +data InputObjectTypeDefinitionSequence = + InputObjectTypeDefinitionSequence { + inputObjectTypeDefinitionSequenceDescription :: (Maybe Description), + inputObjectTypeDefinitionSequenceName :: Name, + inputObjectTypeDefinitionSequenceDirectives :: (Maybe Directives), + inputObjectTypeDefinitionSequenceInputFieldsDefinition :: InputFieldsDefinition} + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeDefinitionSequence = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence" + +_InputObjectTypeDefinitionSequence_Description = Model.Name "Description" + +_InputObjectTypeDefinitionSequence_Name = Model.Name "Name" + +_InputObjectTypeDefinitionSequence_Directives = Model.Name "Directives" + +_InputObjectTypeDefinitionSequence_InputFieldsDefinition = Model.Name "InputFieldsDefinition" + +-- | An input object type definition with no input fields definition. +data InputObjectTypeDefinitionSequence2 = + InputObjectTypeDefinitionSequence2 { + inputObjectTypeDefinitionSequence2Description :: (Maybe Description), + inputObjectTypeDefinitionSequence2Name :: Name, + inputObjectTypeDefinitionSequence2Directives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeDefinitionSequence2 = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeDefinitionSequence2" + +_InputObjectTypeDefinitionSequence2_Description = Model.Name "Description" + +_InputObjectTypeDefinitionSequence2_Name = Model.Name "Name" + +_InputObjectTypeDefinitionSequence2_Directives = Model.Name "Directives" + +-- | An extension of a GraphQL input object type, either with or without input fields. +data InputObjectTypeExtension = + InputObjectTypeExtensionSeq InputObjectTypeExtensionSequence | + InputObjectTypeExtensionSeq2 InputObjectTypeExtensionSequence2 + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeExtension = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtension" + +_InputObjectTypeExtension_seq = Model.Name "seq" + +_InputObjectTypeExtension_seq2 = Model.Name "seq2" + +-- | An input object type extension that adds an input fields definition. +data InputObjectTypeExtensionSequence = + InputObjectTypeExtensionSequence { + inputObjectTypeExtensionSequenceName :: Name, + inputObjectTypeExtensionSequenceDirectives :: (Maybe Directives), + inputObjectTypeExtensionSequenceInputFieldsDefinition :: InputFieldsDefinition} + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeExtensionSequence = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence" + +_InputObjectTypeExtensionSequence_Name = Model.Name "Name" + +_InputObjectTypeExtensionSequence_Directives = Model.Name "Directives" + +_InputObjectTypeExtensionSequence_InputFieldsDefinition = Model.Name "InputFieldsDefinition" + +-- | An input object type extension consisting of directives only. +data InputObjectTypeExtensionSequence2 = + InputObjectTypeExtensionSequence2 { + inputObjectTypeExtensionSequence2Name :: Name, + inputObjectTypeExtensionSequence2Directives :: Directives} + deriving (Eq, Ord, Read, Show) + +_InputObjectTypeExtensionSequence2 = Model.Name "hydra.ext.graphql.syntax.InputObjectTypeExtensionSequence2" + +_InputObjectTypeExtensionSequence2_Name = Model.Name "Name" + +_InputObjectTypeExtensionSequence2_Directives = Model.Name "Directives" + +-- | A single input value definition, used for field arguments and input object fields. +data InputValueDefinition = + InputValueDefinition { + inputValueDefinitionDescription :: (Maybe Description), + inputValueDefinitionName :: Name, + inputValueDefinitionType :: Type, + inputValueDefinitionDefaultValue :: (Maybe DefaultValue), + inputValueDefinitionDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_InputValueDefinition = Model.Name "hydra.ext.graphql.syntax.InputValueDefinition" + +_InputValueDefinition_Description = Model.Name "Description" + +_InputValueDefinition_Name = Model.Name "Name" + +_InputValueDefinition_Type = Model.Name "Type" + +_InputValueDefinition_DefaultValue = Model.Name "DefaultValue" + +_InputValueDefinition_Directives = Model.Name "Directives" + +-- | A GraphQL integer literal. +newtype IntValue = + IntValue { + unIntValue :: String} + deriving (Eq, Ord, Read, Show) + +_IntValue = Model.Name "hydra.ext.graphql.syntax.IntValue" + +-- | A GraphQL interface type definition, either with or without a fields definition. +data InterfaceTypeDefinition = + InterfaceTypeDefinitionSeq InterfaceTypeDefinitionSequence | + InterfaceTypeDefinitionSeq2 InterfaceTypeDefinitionSequence2 + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeDefinition = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinition" + +_InterfaceTypeDefinition_seq = Model.Name "seq" + +_InterfaceTypeDefinition_seq2 = Model.Name "seq2" + +-- | An interface type definition that includes a fields definition. +data InterfaceTypeDefinitionSequence = + InterfaceTypeDefinitionSequence { + interfaceTypeDefinitionSequenceDescription :: (Maybe Description), + interfaceTypeDefinitionSequenceName :: Name, + interfaceTypeDefinitionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), + interfaceTypeDefinitionSequenceDirectives :: (Maybe Directives), + interfaceTypeDefinitionSequenceFieldsDefinition :: FieldsDefinition} + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeDefinitionSequence = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence" + +_InterfaceTypeDefinitionSequence_Description = Model.Name "Description" + +_InterfaceTypeDefinitionSequence_Name = Model.Name "Name" + +_InterfaceTypeDefinitionSequence_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_InterfaceTypeDefinitionSequence_Directives = Model.Name "Directives" + +_InterfaceTypeDefinitionSequence_FieldsDefinition = Model.Name "FieldsDefinition" + +-- | An interface type definition with no fields definition. +data InterfaceTypeDefinitionSequence2 = + InterfaceTypeDefinitionSequence2 { + interfaceTypeDefinitionSequence2Description :: (Maybe Description), + interfaceTypeDefinitionSequence2Name :: Name, + interfaceTypeDefinitionSequence2ImplementsInterfaces :: ImplementsInterfaces, + interfaceTypeDefinitionSequence2Directives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeDefinitionSequence2 = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeDefinitionSequence2" + +_InterfaceTypeDefinitionSequence2_Description = Model.Name "Description" + +_InterfaceTypeDefinitionSequence2_Name = Model.Name "Name" + +_InterfaceTypeDefinitionSequence2_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_InterfaceTypeDefinitionSequence2_Directives = Model.Name "Directives" + +-- | An extension of a GraphQL interface type, in one of three forms. +data InterfaceTypeExtension = + InterfaceTypeExtensionSeq InterfaceTypeExtensionSequence | + InterfaceTypeExtensionSeq2 InterfaceTypeExtensionSequence2 | + InterfaceTypeExtensionSeq3 InterfaceTypeExtensionSequence3 + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeExtension = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtension" + +_InterfaceTypeExtension_seq = Model.Name "seq" + +_InterfaceTypeExtension_seq2 = Model.Name "seq2" + +_InterfaceTypeExtension_seq3 = Model.Name "seq3" + +-- | An interface type extension that adds a fields definition. +data InterfaceTypeExtensionSequence = + InterfaceTypeExtensionSequence { + interfaceTypeExtensionSequenceName :: Name, + interfaceTypeExtensionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), + interfaceTypeExtensionSequenceDirectives :: (Maybe Directives), + interfaceTypeExtensionSequenceFieldsDefinition :: FieldsDefinition} + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeExtensionSequence = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence" + +_InterfaceTypeExtensionSequence_Name = Model.Name "Name" + +_InterfaceTypeExtensionSequence_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_InterfaceTypeExtensionSequence_Directives = Model.Name "Directives" + +_InterfaceTypeExtensionSequence_FieldsDefinition = Model.Name "FieldsDefinition" + +-- | An interface type extension that adds directives but no fields definition. +data InterfaceTypeExtensionSequence2 = + InterfaceTypeExtensionSequence2 { + interfaceTypeExtensionSequence2Name :: Name, + interfaceTypeExtensionSequence2ImplementsInterfaces :: (Maybe ImplementsInterfaces), + interfaceTypeExtensionSequence2Directives :: Directives} + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeExtensionSequence2 = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence2" + +_InterfaceTypeExtensionSequence2_Name = Model.Name "Name" + +_InterfaceTypeExtensionSequence2_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_InterfaceTypeExtensionSequence2_Directives = Model.Name "Directives" + +-- | An interface type extension that adds only implemented interfaces. +data InterfaceTypeExtensionSequence3 = + InterfaceTypeExtensionSequence3 { + interfaceTypeExtensionSequence3Name :: Name, + interfaceTypeExtensionSequence3ImplementsInterfaces :: ImplementsInterfaces} + deriving (Eq, Ord, Read, Show) + +_InterfaceTypeExtensionSequence3 = Model.Name "hydra.ext.graphql.syntax.InterfaceTypeExtensionSequence3" + +_InterfaceTypeExtensionSequence3_Name = Model.Name "Name" + +_InterfaceTypeExtensionSequence3_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +-- | A GraphQL list type, wrapping an inner type in square brackets. +newtype ListType = + ListType { + unListType :: Type} + deriving (Eq, Ord, Read, Show) + +_ListType = Model.Name "hydra.ext.graphql.syntax.ListType" + +-- | A GraphQL list literal, either empty or containing a sequence of values. +data ListValue = + ListValueSeq ListValueSequence | + ListValueSequence2 [Value] + deriving (Eq, Ord, Read, Show) + +_ListValue = Model.Name "hydra.ext.graphql.syntax.ListValue" + +_ListValue_seq = Model.Name "seq" + +_ListValue_sequence2 = Model.Name "sequence2" + +-- | The empty-list form of a GraphQL ListValue. +type ListValueSequence = () + +_ListValueSequence = Model.Name "hydra.ext.graphql.syntax.ListValueSequence" + +-- | A GraphQL name: an identifier matching [_A-Za-z][_0-9A-Za-z]*. +newtype Name = + Name { + unName :: String} + deriving (Eq, Ord, Read, Show) + +_Name = Model.Name "hydra.ext.graphql.syntax.Name" + +-- | A GraphQL named type, referencing a type by its name. +newtype NamedType = + NamedType { + unNamedType :: Name} + deriving (Eq, Ord, Read, Show) + +_NamedType = Model.Name "hydra.ext.graphql.syntax.NamedType" + +-- | A GraphQL non-null type, wrapping a named or list type with a trailing exclamation mark. +data NonNullType = + NonNullTypeNamed NamedType | + NonNullTypeList ListType + deriving (Eq, Ord, Read, Show) + +_NonNullType = Model.Name "hydra.ext.graphql.syntax.NonNullType" + +_NonNullType_named = Model.Name "named" + +_NonNullType_list = Model.Name "list" + +-- | The GraphQL null literal. +newtype NullValue = + NullValue { + unNullValue :: ()} + deriving (Eq, Ord, Read, Show) + +_NullValue = Model.Name "hydra.ext.graphql.syntax.NullValue" + +-- | A single field of a GraphQL object literal, consisting of a name and a value. +data ObjectField = + ObjectField { + objectFieldName :: Name, + objectFieldValue :: Value} + deriving (Eq, Ord, Read, Show) + +_ObjectField = Model.Name "hydra.ext.graphql.syntax.ObjectField" + +_ObjectField_Name = Model.Name "Name" + +_ObjectField_Value = Model.Name "Value" + +-- | A GraphQL object type definition, giving its name, interfaces, directives, and fields. +data ObjectTypeDefinition = + ObjectTypeDefinition { + objectTypeDefinitionDescription :: (Maybe Description), + objectTypeDefinitionName :: Name, + objectTypeDefinitionImplementsInterfaces :: (Maybe ImplementsInterfaces), + objectTypeDefinitionDirectives :: (Maybe Directives), + objectTypeDefinitionFieldsDefinition :: (Maybe FieldsDefinition)} + deriving (Eq, Ord, Read, Show) + +_ObjectTypeDefinition = Model.Name "hydra.ext.graphql.syntax.ObjectTypeDefinition" + +_ObjectTypeDefinition_Description = Model.Name "Description" + +_ObjectTypeDefinition_Name = Model.Name "Name" + +_ObjectTypeDefinition_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_ObjectTypeDefinition_Directives = Model.Name "Directives" + +_ObjectTypeDefinition_FieldsDefinition = Model.Name "FieldsDefinition" + +-- | An extension of a GraphQL object type, in one of three forms. +data ObjectTypeExtension = + ObjectTypeExtensionSeq ObjectTypeExtensionSequence | + ObjectTypeExtensionSeq2 ObjectTypeExtensionSequence2 | + ObjectTypeExtensionSeq3 ObjectTypeExtensionSequence3 + deriving (Eq, Ord, Read, Show) + +_ObjectTypeExtension = Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtension" + +_ObjectTypeExtension_seq = Model.Name "seq" + +_ObjectTypeExtension_seq2 = Model.Name "seq2" + +_ObjectTypeExtension_seq3 = Model.Name "seq3" + +-- | An object type extension that adds a fields definition. +data ObjectTypeExtensionSequence = + ObjectTypeExtensionSequence { + objectTypeExtensionSequenceName :: Name, + objectTypeExtensionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), + objectTypeExtensionSequenceDirectives :: (Maybe Directives), + objectTypeExtensionSequenceFieldsDefinition :: FieldsDefinition} + deriving (Eq, Ord, Read, Show) + +_ObjectTypeExtensionSequence = Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence" + +_ObjectTypeExtensionSequence_Name = Model.Name "Name" + +_ObjectTypeExtensionSequence_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_ObjectTypeExtensionSequence_Directives = Model.Name "Directives" + +_ObjectTypeExtensionSequence_FieldsDefinition = Model.Name "FieldsDefinition" + +-- | An object type extension that adds directives but no fields definition. +data ObjectTypeExtensionSequence2 = + ObjectTypeExtensionSequence2 { + objectTypeExtensionSequence2Name :: Name, + objectTypeExtensionSequence2ImplementsInterfaces :: (Maybe ImplementsInterfaces), + objectTypeExtensionSequence2Directives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_ObjectTypeExtensionSequence2 = Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence2" + +_ObjectTypeExtensionSequence2_Name = Model.Name "Name" + +_ObjectTypeExtensionSequence2_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +_ObjectTypeExtensionSequence2_Directives = Model.Name "Directives" + +-- | An object type extension that adds only implemented interfaces. +data ObjectTypeExtensionSequence3 = + ObjectTypeExtensionSequence3 { + objectTypeExtensionSequence3Name :: Name, + objectTypeExtensionSequence3ImplementsInterfaces :: ImplementsInterfaces} + deriving (Eq, Ord, Read, Show) + +_ObjectTypeExtensionSequence3 = Model.Name "hydra.ext.graphql.syntax.ObjectTypeExtensionSequence3" + +_ObjectTypeExtensionSequence3_Name = Model.Name "Name" + +_ObjectTypeExtensionSequence3_ImplementsInterfaces = Model.Name "ImplementsInterfaces" + +-- | A GraphQL object literal, either empty or containing a sequence of object fields. +data ObjectValue = + ObjectValueSeq ObjectValueSequence | + ObjectValueSequence2 [ObjectField] + deriving (Eq, Ord, Read, Show) + +_ObjectValue = Model.Name "hydra.ext.graphql.syntax.ObjectValue" + +_ObjectValue_seq = Model.Name "seq" + +_ObjectValue_sequence2 = Model.Name "sequence2" + +-- | The empty-object form of a GraphQL ObjectValue. +type ObjectValueSequence = () + +_ObjectValueSequence = Model.Name "hydra.ext.graphql.syntax.ObjectValueSequence" + +-- | A GraphQL operation definition, either a shorthand query or an explicit operation. +data OperationDefinition = + OperationDefinitionSeq OperationDefinitionSequence | + OperationDefinitionSelectionSet SelectionSet + deriving (Eq, Ord, Read, Show) + +_OperationDefinition = Model.Name "hydra.ext.graphql.syntax.OperationDefinition" + +_OperationDefinition_seq = Model.Name "seq" + +_OperationDefinition_SelectionSet = Model.Name "SelectionSet" + +-- | An explicit GraphQL operation definition with a type, optional name, variables, and directives. +data OperationDefinitionSequence = + OperationDefinitionSequence { + operationDefinitionSequenceOperationType :: OperationType, + operationDefinitionSequenceName :: (Maybe Name), + operationDefinitionSequenceVariablesDefinition :: (Maybe VariablesDefinition), + operationDefinitionSequenceDirectives :: (Maybe Directives), + operationDefinitionSequenceSelectionSet :: SelectionSet} + deriving (Eq, Ord, Read, Show) + +_OperationDefinitionSequence = Model.Name "hydra.ext.graphql.syntax.OperationDefinitionSequence" + +_OperationDefinitionSequence_OperationType = Model.Name "OperationType" + +_OperationDefinitionSequence_Name = Model.Name "Name" + +_OperationDefinitionSequence_VariablesDefinition = Model.Name "VariablesDefinition" + +_OperationDefinitionSequence_Directives = Model.Name "Directives" + +_OperationDefinitionSequence_SelectionSet = Model.Name "SelectionSet" + +-- | The type of a GraphQL operation: query, mutation, or subscription. +data OperationType = + OperationTypeQuery | + OperationTypeMutation | + OperationTypeSubscription + deriving (Eq, Ord, Read, Show) + +_OperationType = Model.Name "hydra.ext.graphql.syntax.OperationType" + +_OperationType_Query = Model.Name "Query" + +_OperationType_Mutation = Model.Name "Mutation" + +_OperationType_Subscription = Model.Name "Subscription" + +-- | A mapping from a GraphQL operation type to its root object type. +data RootOperationTypeDefinition = + RootOperationTypeDefinition { + rootOperationTypeDefinitionOperationType :: OperationType, + rootOperationTypeDefinitionNamedType :: NamedType} + deriving (Eq, Ord, Read, Show) + +_RootOperationTypeDefinition = Model.Name "hydra.ext.graphql.syntax.RootOperationTypeDefinition" + +_RootOperationTypeDefinition_OperationType = Model.Name "OperationType" + +_RootOperationTypeDefinition_NamedType = Model.Name "NamedType" + +-- | A GraphQL scalar type definition, with optional description and directives. +data ScalarTypeDefinition = + ScalarTypeDefinition { + scalarTypeDefinitionDescription :: (Maybe Description), + scalarTypeDefinitionName :: Name, + scalarTypeDefinitionDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_ScalarTypeDefinition = Model.Name "hydra.ext.graphql.syntax.ScalarTypeDefinition" + +_ScalarTypeDefinition_Description = Model.Name "Description" + +_ScalarTypeDefinition_Name = Model.Name "Name" + +_ScalarTypeDefinition_Directives = Model.Name "Directives" + +-- | An extension of a GraphQL scalar type, adding directives. +data ScalarTypeExtension = + ScalarTypeExtension { + scalarTypeExtensionName :: Name, + scalarTypeExtensionDirectives :: Directives} + deriving (Eq, Ord, Read, Show) + +_ScalarTypeExtension = Model.Name "hydra.ext.graphql.syntax.ScalarTypeExtension" + +_ScalarTypeExtension_Name = Model.Name "Name" + +_ScalarTypeExtension_Directives = Model.Name "Directives" + +-- | A GraphQL schema definition, declaring its root operation types. +data SchemaDefinition = + SchemaDefinition { + schemaDefinitionDescription :: (Maybe Description), + schemaDefinitionDirectives :: (Maybe Directives), + schemaDefinitionRootOperationTypeDefinition :: RootOperationTypeDefinition} + deriving (Eq, Ord, Read, Show) + +_SchemaDefinition = Model.Name "hydra.ext.graphql.syntax.SchemaDefinition" + +_SchemaDefinition_Description = Model.Name "Description" + +_SchemaDefinition_Directives = Model.Name "Directives" + +_SchemaDefinition_RootOperationTypeDefinition = Model.Name "RootOperationTypeDefinition" + +-- | An extension of a GraphQL schema, adding root operation types or directives. +data SchemaExtension = + SchemaExtensionSeq SchemaExtensionSequence | + SchemaExtensionSequence2 Directives + deriving (Eq, Ord, Read, Show) + +_SchemaExtension = Model.Name "hydra.ext.graphql.syntax.SchemaExtension" + +_SchemaExtension_seq = Model.Name "seq" + +_SchemaExtension_sequence2 = Model.Name "sequence2" + +-- | A schema extension that adds a root operation type definition. +data SchemaExtensionSequence = + SchemaExtensionSequence { + schemaExtensionSequenceDirectives :: (Maybe Directives), + schemaExtensionSequenceRootOperationTypeDefinition :: RootOperationTypeDefinition} + deriving (Eq, Ord, Read, Show) + +_SchemaExtensionSequence = Model.Name "hydra.ext.graphql.syntax.SchemaExtensionSequence" + +_SchemaExtensionSequence_Directives = Model.Name "Directives" + +_SchemaExtensionSequence_RootOperationTypeDefinition = Model.Name "RootOperationTypeDefinition" + +-- | A single selection within a GraphQL selection set: a field, fragment spread, or inline fragment. +data Selection = + SelectionField Field | + SelectionFragmentSpread FragmentSpread | + SelectionInlineFragment InlineFragment + deriving (Eq, Ord, Read, Show) + +_Selection = Model.Name "hydra.ext.graphql.syntax.Selection" + +_Selection_Field = Model.Name "Field" + +_Selection_FragmentSpread = Model.Name "FragmentSpread" + +_Selection_InlineFragment = Model.Name "InlineFragment" + +-- | A braced list of GraphQL selections. +newtype SelectionSet = + SelectionSet { + unSelectionSet :: [Selection]} + deriving (Eq, Ord, Read, Show) + +_SelectionSet = Model.Name "hydra.ext.graphql.syntax.SelectionSet" + +-- | A GraphQL string literal. +newtype StringValue = + StringValue { + unStringValue :: String} + deriving (Eq, Ord, Read, Show) + +_StringValue = Model.Name "hydra.ext.graphql.syntax.StringValue" + +-- | A GraphQL type reference: named, list, or non-null. +data Type = + TypeNamed NamedType | + TypeList ListType | + TypeNonNull NonNullType + deriving (Eq, Ord, Read, Show) + +_Type = Model.Name "hydra.ext.graphql.syntax.Type" + +_Type_named = Model.Name "named" + +_Type_list = Model.Name "list" + +_Type_nonNull = Model.Name "nonNull" + +-- | A GraphQL type condition, naming the type a fragment applies to. +data TypeCondition = + TypeConditionOn | + TypeConditionNamedType NamedType + deriving (Eq, Ord, Read, Show) + +_TypeCondition = Model.Name "hydra.ext.graphql.syntax.TypeCondition" + +_TypeCondition_On = Model.Name "On" + +_TypeCondition_NamedType = Model.Name "NamedType" + +-- | A GraphQL type system definition for a single named type. +data TypeDefinition = + TypeDefinitionScalar ScalarTypeDefinition | + TypeDefinitionObject ObjectTypeDefinition | + TypeDefinitionInterface InterfaceTypeDefinition | + TypeDefinitionUnion UnionTypeDefinition | + TypeDefinitionEnum EnumTypeDefinition | + TypeDefinitionInputObject InputObjectTypeDefinition + deriving (Eq, Ord, Read, Show) + +_TypeDefinition = Model.Name "hydra.ext.graphql.syntax.TypeDefinition" + +_TypeDefinition_scalar = Model.Name "scalar" + +_TypeDefinition_object = Model.Name "object" + +_TypeDefinition_interface = Model.Name "interface" + +_TypeDefinition_union = Model.Name "union" + +_TypeDefinition_enum = Model.Name "enum" + +_TypeDefinition_inputObject = Model.Name "inputObject" + +-- | An extension of a GraphQL named type. +data TypeExtension = + TypeExtensionScalar ScalarTypeExtension | + TypeExtensionObject ObjectTypeExtension | + TypeExtensionInterface InterfaceTypeExtension | + TypeExtensionUnion UnionTypeExtension | + TypeExtensionEnum EnumTypeExtension | + TypeExtensionInputObject InputObjectTypeExtension + deriving (Eq, Ord, Read, Show) + +_TypeExtension = Model.Name "hydra.ext.graphql.syntax.TypeExtension" + +_TypeExtension_scalar = Model.Name "scalar" + +_TypeExtension_object = Model.Name "object" + +_TypeExtension_interface = Model.Name "interface" + +_TypeExtension_union = Model.Name "union" + +_TypeExtension_enum = Model.Name "enum" + +_TypeExtension_inputObject = Model.Name "inputObject" + +-- | A GraphQL type system definition: schema, type, or directive. +data TypeSystemDefinition = + TypeSystemDefinitionSchema SchemaDefinition | + TypeSystemDefinitionType TypeDefinition | + TypeSystemDefinitionDirective DirectiveDefinition + deriving (Eq, Ord, Read, Show) + +_TypeSystemDefinition = Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinition" + +_TypeSystemDefinition_schema = Model.Name "schema" + +_TypeSystemDefinition_type = Model.Name "type" + +_TypeSystemDefinition_directive = Model.Name "directive" + +-- | Either a GraphQL type system definition or an extension of one. +data TypeSystemDefinitionOrExtension = + TypeSystemDefinitionOrExtensionDefinition TypeSystemDefinition | + TypeSystemDefinitionOrExtensionExtension TypeSystemExtension + deriving (Eq, Ord, Read, Show) + +_TypeSystemDefinitionOrExtension = Model.Name "hydra.ext.graphql.syntax.TypeSystemDefinitionOrExtension" + +_TypeSystemDefinitionOrExtension_definition = Model.Name "definition" + +_TypeSystemDefinitionOrExtension_extension = Model.Name "extension" + +-- | A directive location valid on GraphQL type system definitions. +data TypeSystemDirectiveLocation = + TypeSystemDirectiveLocationSCHEMA | + TypeSystemDirectiveLocationSCALAR | + TypeSystemDirectiveLocationOBJECT | + TypeSystemDirectiveLocationFIELD_DEFINITION | + TypeSystemDirectiveLocationARGUMENT_DEFINITION | + TypeSystemDirectiveLocationINTERFACE | + TypeSystemDirectiveLocationUNION | + TypeSystemDirectiveLocationENUM | + TypeSystemDirectiveLocationENUM_VALUE | + TypeSystemDirectiveLocationINPUT_OBJECT | + TypeSystemDirectiveLocationINPUT_FIELD_DEFINITION + deriving (Eq, Ord, Read, Show) + +_TypeSystemDirectiveLocation = Model.Name "hydra.ext.graphql.syntax.TypeSystemDirectiveLocation" + +_TypeSystemDirectiveLocation_SCHEMA = Model.Name "SCHEMA" + +_TypeSystemDirectiveLocation_SCALAR = Model.Name "SCALAR" + +_TypeSystemDirectiveLocation_OBJECT = Model.Name "OBJECT" + +_TypeSystemDirectiveLocation_FIELD_DEFINITION = Model.Name "FIELD_DEFINITION" + +_TypeSystemDirectiveLocation_ARGUMENT_DEFINITION = Model.Name "ARGUMENT_DEFINITION" + +_TypeSystemDirectiveLocation_INTERFACE = Model.Name "INTERFACE" + +_TypeSystemDirectiveLocation_UNION = Model.Name "UNION" + +_TypeSystemDirectiveLocation_ENUM = Model.Name "ENUM" + +_TypeSystemDirectiveLocation_ENUM_VALUE = Model.Name "ENUM_VALUE" + +_TypeSystemDirectiveLocation_INPUT_OBJECT = Model.Name "INPUT_OBJECT" + +_TypeSystemDirectiveLocation_INPUT_FIELD_DEFINITION = Model.Name "INPUT_FIELD_DEFINITION" + +-- | A GraphQL document consisting only of type system definitions. +newtype TypeSystemDocment = + TypeSystemDocment { + unTypeSystemDocment :: [TypeSystemDefinition]} + deriving (Eq, Ord, Read, Show) + +_TypeSystemDocment = Model.Name "hydra.ext.graphql.syntax.TypeSystemDocment" + +-- | An extension of a GraphQL schema or type. +data TypeSystemExtension = + TypeSystemExtensionSchema SchemaExtension | + TypeSystemExtensionType TypeExtension + deriving (Eq, Ord, Read, Show) + +_TypeSystemExtension = Model.Name "hydra.ext.graphql.syntax.TypeSystemExtension" + +_TypeSystemExtension_schema = Model.Name "schema" + +_TypeSystemExtension_type = Model.Name "type" + +-- | A GraphQL document consisting of type system definitions and extensions. +newtype TypeSystemExtensionDocument = + TypeSystemExtensionDocument { + unTypeSystemExtensionDocument :: [TypeSystemDefinitionOrExtension]} + deriving (Eq, Ord, Read, Show) + +_TypeSystemExtensionDocument = Model.Name "hydra.ext.graphql.syntax.TypeSystemExtensionDocument" + +-- | The list of member types of a GraphQL union type, introduced by an equals sign. +data UnionMemberTypes = + UnionMemberTypesSeq UnionMemberTypesSequence | + UnionMemberTypesSeq2 UnionMemberTypesSequence2 + deriving (Eq, Ord, Read, Show) + +_UnionMemberTypes = Model.Name "hydra.ext.graphql.syntax.UnionMemberTypes" + +_UnionMemberTypes_seq = Model.Name "seq" + +_UnionMemberTypes_seq2 = Model.Name "seq2" + +-- | A non-empty UnionMemberTypes list with a leading list of member types. +data UnionMemberTypesSequence = + UnionMemberTypesSequence { + unionMemberTypesSequenceUnionMemberTypes :: UnionMemberTypes, + unionMemberTypesSequenceNamedType :: NamedType} + deriving (Eq, Ord, Read, Show) + +_UnionMemberTypesSequence = Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence" + +_UnionMemberTypesSequence_UnionMemberTypes = Model.Name "UnionMemberTypes" + +_UnionMemberTypesSequence_NamedType = Model.Name "NamedType" + +-- | The base case of a UnionMemberTypes list: a single, optionally pipe-prefixed member type. +data UnionMemberTypesSequence2 = + UnionMemberTypesSequence2 { + unionMemberTypesSequence2Or :: (Maybe ()), + unionMemberTypesSequence2NamedType :: NamedType} + deriving (Eq, Ord, Read, Show) + +_UnionMemberTypesSequence2 = Model.Name "hydra.ext.graphql.syntax.UnionMemberTypesSequence2" + +_UnionMemberTypesSequence2_Or = Model.Name "Or" + +_UnionMemberTypesSequence2_NamedType = Model.Name "NamedType" + +-- | A GraphQL union type definition, giving its name, directives, and member types. +data UnionTypeDefinition = + UnionTypeDefinition { + unionTypeDefinitionDescription :: (Maybe Description), + unionTypeDefinitionName :: Name, + unionTypeDefinitionDirectives :: (Maybe Directives), + unionTypeDefinitionUnionMemberTypes :: (Maybe UnionMemberTypes)} + deriving (Eq, Ord, Read, Show) + +_UnionTypeDefinition = Model.Name "hydra.ext.graphql.syntax.UnionTypeDefinition" + +_UnionTypeDefinition_Description = Model.Name "Description" + +_UnionTypeDefinition_Name = Model.Name "Name" + +_UnionTypeDefinition_Directives = Model.Name "Directives" + +_UnionTypeDefinition_UnionMemberTypes = Model.Name "UnionMemberTypes" + +-- | An extension of a GraphQL union type, either adding member types or only directives. +data UnionTypeExtension = + UnionTypeExtensionSeq UnionTypeExtensionSequence | + UnionTypeExtensionSeq2 UnionTypeExtensionSequence2 + deriving (Eq, Ord, Read, Show) + +_UnionTypeExtension = Model.Name "hydra.ext.graphql.syntax.UnionTypeExtension" + +_UnionTypeExtension_seq = Model.Name "seq" + +_UnionTypeExtension_seq2 = Model.Name "seq2" + +-- | A union type extension that adds new member types. +data UnionTypeExtensionSequence = + UnionTypeExtensionSequence { + unionTypeExtensionSequenceName :: Name, + unionTypeExtensionSequenceDirectives :: (Maybe Directives), + unionTypeExtensionSequenceUnionMemberTypes :: UnionMemberTypes} + deriving (Eq, Ord, Read, Show) + +_UnionTypeExtensionSequence = Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence" + +_UnionTypeExtensionSequence_Name = Model.Name "Name" + +_UnionTypeExtensionSequence_Directives = Model.Name "Directives" + +_UnionTypeExtensionSequence_UnionMemberTypes = Model.Name "UnionMemberTypes" + +-- | A union type extension consisting of directives only. +data UnionTypeExtensionSequence2 = + UnionTypeExtensionSequence2 { + unionTypeExtensionSequence2Name :: Name, + unionTypeExtensionSequence2Directives :: Directives} + deriving (Eq, Ord, Read, Show) + +_UnionTypeExtensionSequence2 = Model.Name "hydra.ext.graphql.syntax.UnionTypeExtensionSequence2" + +_UnionTypeExtensionSequence2_Name = Model.Name "Name" + +_UnionTypeExtensionSequence2_Directives = Model.Name "Directives" + +-- | A GraphQL value: a variable, literal, list, or object. +data Value = + ValueVariable Variable | + ValueInt IntValue | + ValueFloat FloatValue | + ValueString StringValue | + ValueBoolean BooleanValue | + ValueNull NullValue | + ValueEnum EnumValue | + ValueList ListValue | + ValueObject ObjectValue + deriving (Eq, Ord, Read, Show) + +_Value = Model.Name "hydra.ext.graphql.syntax.Value" + +_Value_Variable = Model.Name "Variable" + +_Value_int = Model.Name "int" + +_Value_float = Model.Name "float" + +_Value_string = Model.Name "string" + +_Value_boolean = Model.Name "boolean" + +_Value_null = Model.Name "null" + +_Value_enum = Model.Name "enum" + +_Value_list = Model.Name "list" + +_Value_object = Model.Name "object" + +-- | A GraphQL variable reference, introduced by a dollar sign. +newtype Variable = + Variable { + unVariable :: Name} + deriving (Eq, Ord, Read, Show) + +_Variable = Model.Name "hydra.ext.graphql.syntax.Variable" + +-- | A single variable definition in a GraphQL operation's variable list. +data VariablesDefinition = + VariablesDefinition { + variablesDefinitionVariable :: Variable, + variablesDefinitionType :: Type, + variablesDefinitionDefaultValue :: (Maybe DefaultValue), + variablesDefinitionDirectives :: (Maybe Directives)} + deriving (Eq, Ord, Read, Show) + +_VariablesDefinition = Model.Name "hydra.ext.graphql.syntax.VariablesDefinition" + +_VariablesDefinition_Variable = Model.Name "Variable" + +_VariablesDefinition_Type = Model.Name "Type" + +_VariablesDefinition_DefaultValue = Model.Name "DefaultValue" + +_VariablesDefinition_Directives = Model.Name "Directives" diff --git a/src/main/haskell/Hydra/Ext/Iana/Linkrelations.hs b/src/main/haskell/Hydra/Ext/Iana/Linkrelations.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Iana/Linkrelations.hs @@ -0,0 +1,500 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | All IANA Link Relation Types, as of 2022-10-11. See https://www.iana.org/assignments/link-relations/link-relations.xhtml + +module Hydra.Ext.Iana.Linkrelations where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | An IANA link relation type +data LinkRelationType = + -- | Refers to a resource that is the subject of the link's context. [RFC6903], section 2 + LinkRelationTypeAbout | + -- | Asserts that the link target provides an access control resource for the link context. [https://solidproject.org/TR/wac#acl-link-relation] + LinkRelationTypeAcl | + -- | Refers to a substitute for this context [HTML] + LinkRelationTypeAlternate | + -- | Used to reference alternative content that uses the AMP profile of the HTML format. [AMP HTML] + LinkRelationTypeAmphtml | + -- | Refers to an appendix. [HTML 4.01 Specification] + LinkRelationTypeAppendix | + -- | Refers to an icon for the context. Synonym for icon. [Configuring Web Applications] + LinkRelationTypeApple_touch_icon | + -- | Refers to a launch screen for the context. [Configuring Web Applications] + LinkRelationTypeApple_touch_startup_image | + -- | Refers to a collection of records, documents, or other materials of historical interest. [HTML5] + LinkRelationTypeArchives | + -- | Refers to the context's author. [HTML] + LinkRelationTypeAuthor | + -- | Identifies the entity that blocks access to a resource following receipt of a legal demand. [RFC7725] + LinkRelationTypeBlocked_by | + -- | Gives a permanent link to use for bookmarking purposes. [HTML] + LinkRelationTypeBookmark | + -- | Designates the preferred version of a resource (the IRI and its contents). [RFC6596] + LinkRelationTypeCanonical | + -- | Refers to a chapter in a collection of resources. [HTML 4.01 Specification] + LinkRelationTypeChapter | + -- | Indicates that the link target is preferred over the link context for the purpose of permanent citation. [RFC8574] + LinkRelationTypeCite_as | + -- | The target IRI points to a resource which represents the collection resource for the context IRI. [RFC6573] + LinkRelationTypeCollection | + -- | Refers to a table of contents. [HTML 4.01 Specification] + LinkRelationTypeContents | + -- | The document linked to was later converted to the document that contains this link relation. For example, an RFC can have a link to the Internet-Draft that became the RFC; in that case, the link relation would be "convertedFrom". [RFC7991] This relation is different than "predecessor-version" in that "predecessor-version" is for items in a version control system. It is also different than "previous" in that this relation is used for converted resources, not those that are part of a sequence of resources. + LinkRelationTypeConvertedfrom | + -- | Refers to a copyright statement that applies to the link's context. [HTML 4.01 Specification] + LinkRelationTypeCopyright | + -- | The target IRI points to a resource where a submission form can be obtained. [RFC6861] + LinkRelationTypeCreate_form | + -- | Refers to a resource containing the most recent item(s) in a collection of resources. [RFC5005] + LinkRelationTypeCurrent | + -- | Refers to a resource providing information about the link's context. [Protocol for Web Description Resources (POWDER)] + LinkRelationTypeDescribedby | + -- | The relationship A 'describes' B asserts that resource A provides a description of resource B. There are no constraints on the format or representation of either A or B, neither are there any further constraints on either resource. [RFC6892] This link relation type is the inverse of the 'describedby' relation type. While 'describedby' establishes a relation from the described resource back to the resource that describes it, 'describes' established a relation from the describing resource to the resource it describes. If B is 'describedby' A, then A 'describes' B. + LinkRelationTypeDescribes | + -- | Refers to a list of patent disclosures made with respect to material for which 'disclosure' relation is specified. [RFC6579] + LinkRelationTypeDisclosure | + -- | Used to indicate an origin that will be used to fetch required resources for the link context, and that the user agent ought to resolve as early as possible. [Resource Hints] + LinkRelationTypeDns_prefetch | + -- | Refers to a resource whose available representations are byte-for-byte identical with the corresponding representations of the context IRI. [RFC6249] This relation is for static resources. That is, an HTTP GET request on any duplicate will return the same representation. It does not make sense for dynamic or POSTable resources and should not be used for them. + LinkRelationTypeDuplicate | + -- | Refers to a resource that can be used to edit the link's context. [RFC5023] + LinkRelationTypeEdit | + -- | The target IRI points to a resource where a submission form for editing associated resource can be obtained. [RFC6861] + LinkRelationTypeEdit_form | + -- | Refers to a resource that can be used to edit media associated with the link's context. [RFC5023] + LinkRelationTypeEdit_media | + -- | Identifies a related resource that is potentially large and might require special handling. [RFC4287] + LinkRelationTypeEnclosure | + -- | Refers to a resource that is not part of the same site as the current context. [HTML] + LinkRelationTypeExternal | + -- | An IRI that refers to the furthest preceding resource in a series of resources. [RFC8288] This relation type registration did not indicate a reference. Originally requested by Mark Nottingham in December 2004. + LinkRelationTypeFirst | + -- | Refers to a glossary of terms. [HTML 4.01 Specification] + LinkRelationTypeGlossary | + -- | Refers to context-sensitive help. [HTML] + LinkRelationTypeHelp | + -- | Refers to a resource hosted by the server indicated by the link context. [RFC6690] This relation is used in CoRE where links are retrieved as a "/.well-known/core" resource representation, and is the default relation type in the CoRE Link Format. + LinkRelationTypeHosts | + -- | Refers to a hub that enables registration for notification of updates to the context. [WebSub] This relation type was requested by Brett Slatkin. + LinkRelationTypeHub | + -- | Refers to an icon representing the link's context. [HTML] + LinkRelationTypeIcon | + -- | Refers to an index. [HTML 4.01 Specification] + LinkRelationTypeIndex | + -- | refers to a resource associated with a time interval that ends before the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.21 + LinkRelationTypeIntervalafter | + -- | refers to a resource associated with a time interval that begins after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.22 + LinkRelationTypeIntervalbefore | + -- | refers to a resource associated with a time interval that begins after the beginning of the time interval associated with the context resource, and ends before the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.23 + LinkRelationTypeIntervalcontains | + -- | refers to a resource associated with a time interval that begins after the end of the time interval associated with the context resource, or ends before the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.24 + LinkRelationTypeIntervaldisjoint | + -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.25 + LinkRelationTypeIntervalduring | + -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.26 + LinkRelationTypeIntervalequals | + -- | refers to a resource associated with a time interval that begins after the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.27 + LinkRelationTypeIntervalfinishedby | + -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.28 + LinkRelationTypeIntervalfinishes | + -- | refers to a resource associated with a time interval that begins before or is coincident with the beginning of the time interval associated with the context resource, and ends after or is coincident with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.29 + LinkRelationTypeIntervalin | + -- | refers to a resource associated with a time interval whose beginning coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.30 + LinkRelationTypeIntervalmeets | + -- | refers to a resource associated with a time interval whose end coincides with the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.31 + LinkRelationTypeIntervalmetby | + -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and ends after the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.32 + LinkRelationTypeIntervaloverlappedby | + -- | refers to a resource associated with a time interval that begins before the end of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.33 + LinkRelationTypeIntervaloverlaps | + -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and ends before the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.34 + LinkRelationTypeIntervalstartedby | + -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.35 + LinkRelationTypeIntervalstarts | + -- | The target IRI points to a resource that is a member of the collection represented by the context IRI. [RFC6573] + LinkRelationTypeItem | + -- | An IRI that refers to the furthest following resource in a series of resources. [RFC8288] This relation type registration did not indicate a reference. Originally requested by Mark Nottingham in December 2004. + LinkRelationTypeLast | + -- | Points to a resource containing the latest (e.g., current) version of the context. [RFC5829] + LinkRelationTypeLatest_version | + -- | Refers to a license associated with this context. [RFC4946] For implications of use in HTML, see: http://www.w3.org/TR/html5/links.html#link-type-license + LinkRelationTypeLicense | + -- | The link target of a link with the "linkset" relation type provides a set of links, including links in which the link context of the link participates. [RFC9264] + LinkRelationTypeLinkset | + -- | Refers to further information about the link's context, expressed as a LRDD ("Link-based Resource Descriptor Document") resource. See [RFC6415] for information about processing this relation type in host-meta documents. When used elsewhere, it refers to additional links and other metadata. Multiple instances indicate additional LRDD resources. LRDD resources MUST have an "application/xrd+xml" representation, and MAY have others. [RFC6415] + LinkRelationTypeLrdd | + -- | Links to a manifest file for the context. [Web App Manifest] + LinkRelationTypeManifest | + -- | Refers to a mask that can be applied to the icon for the context. [Creating Pinned Tab Icons] + LinkRelationTypeMask_icon | + -- | Refers to a feed of personalised media recommendations relevant to the link context. [https://wicg.github.io/media-feeds/#discovery-of-media-feeds] + LinkRelationTypeMedia_feed | + -- | The Target IRI points to a Memento, a fixed resource that will not change state anymore. [RFC7089] A Memento for an Original Resource is a resource that encapsulates a prior state of the Original Resource. + LinkRelationTypeMemento | + -- | Links to the context's Micropub endpoint. [Micropub] + LinkRelationTypeMicropub | + -- | Refers to a module that the user agent is to preemptively fetch and store for use in the current context. [HTML] + LinkRelationTypeModulepreload | + -- | Refers to a resource that can be used to monitor changes in an HTTP resource. [RFC5989] + LinkRelationTypeMonitor | + -- | Refers to a resource that can be used to monitor changes in a specified group of HTTP resources. [RFC5989] + LinkRelationTypeMonitor_group | + -- | Indicates that the link's context is a part of a series, and that the next in the series is the link target. [HTML] + LinkRelationTypeNext | + -- | Refers to the immediately following archive resource. [RFC5005] + LinkRelationTypeNext_archive | + -- | Indicates that the context's original author or publisher does not endorse the link target. [HTML] + LinkRelationTypeNofollow | + -- | Indicates that any newly created top-level browsing context which results from following the link will not be an auxiliary browsing context. [HTML] + LinkRelationTypeNoopener | + -- | Indicates that no referrer information is to be leaked when following the link. [HTML] + LinkRelationTypeNoreferrer | + -- | Indicates that any newly created top-level browsing context which results from following the link will be an auxiliary browsing context. [HTML] + LinkRelationTypeOpener | + -- | Refers to an OpenID Authentication server on which the context relies for an assertion that the end user controls an Identifier. [OpenID Authentication 2.0 - Final] + LinkRelationTypeOpenid2_local_id | + -- | Refers to a resource which accepts OpenID Authentication protocol messages for the context. [OpenID Authentication 2.0 - Final] + LinkRelationTypeOpenid2_provider | + -- | The Target IRI points to an Original Resource. [RFC7089] An Original Resource is a resource that exists or used to exist, and for which access to one of its prior states may be required. + LinkRelationTypeOriginal | + -- | Refers to a P3P privacy policy for the context. [The Platform for Privacy Preferences 1.0 (P3P1.0) Specification] + LinkRelationTypeP3pv1 | + -- | Indicates a resource where payment is accepted. [RFC8288] This relation type registration did not indicate a reference. Requested by Joshua Kinberg and Robert Sayre. It is meant as a general way to facilitate acts of payment, and thus this specification makes no assumptions on the type of payment or transaction protocol. Examples may include a web page where donations are accepted or where goods and services are available for purchase. rel="payment" is not intended to initiate an automated transaction. In Atom documents, a link element with a rel="payment" attribute may exist at the feed/channel level and/or the entry/item level. For example, a rel="payment" link at the feed/channel level may point to a "tip jar" URI, whereas an entry/ item containing a book review may include a rel="payment" link that points to the location where the book may be purchased through an online retailer. + LinkRelationTypePayment | + -- | Gives the address of the pingback resource for the link context. [Pingback 1.0] + LinkRelationTypePingback | + -- | Used to indicate an origin that will be used to fetch required resources for the link context. Initiating an early connection, which includes the DNS lookup, TCP handshake, and optional TLS negotiation, allows the user agent to mask the high latency costs of establishing a connection. [Resource Hints] + LinkRelationTypePreconnect | + -- | Points to a resource containing the predecessor version in the version history. [RFC5829] + LinkRelationTypePredecessor_version | + -- | The prefetch link relation type is used to identify a resource that might be required by the next navigation from the link context, and that the user agent ought to fetch, such that the user agent can deliver a faster response once the resource is requested in the future. [Resource Hints] + LinkRelationTypePrefetch | + -- | Refers to a resource that should be loaded early in the processing of the link's context, without blocking rendering. [Preload] Additional target attributes establish the detailed fetch properties of the link. + LinkRelationTypePreload | + -- | Used to identify a resource that might be required by the next navigation from the link context, and that the user agent ought to fetch and execute, such that the user agent can deliver a faster response once the resource is requested in the future. [Resource Hints] + LinkRelationTypePrerender | + -- | Indicates that the link's context is a part of a series, and that the previous in the series is the link target. [HTML] + LinkRelationTypePrev | + -- | Refers to a resource that provides a preview of the link's context. [RFC6903], section 3 + LinkRelationTypePreview | + -- | Refers to the previous resource in an ordered series of resources. Synonym for "prev". [HTML 4.01 Specification] + LinkRelationTypePrevious | + -- | Refers to the immediately preceding archive resource. [RFC5005] + LinkRelationTypePrev_archive | + -- | Refers to a privacy policy associated with the link's context. [RFC6903], section 4 + LinkRelationTypePrivacy_policy | + -- | Identifying that a resource representation conforms to a certain profile, without affecting the non-profile semantics of the resource representation. [RFC6906] Profile URIs are primarily intended to be used as identifiers, and thus clients SHOULD NOT indiscriminately access profile URIs. + LinkRelationTypeProfile | + -- | Links to a publication manifest. A manifest represents structured information about a publication, such as informative metadata, a list of resources, and a default reading order. [Publication Manifest] + LinkRelationTypePublication | + -- | Identifies a related resource. [RFC4287] + LinkRelationTypeRelated | + -- | Identifies the root of RESTCONF API as configured on this HTTP server. The "restconf" relation defines the root of the API defined in RFC8040. Subsequent revisions of RESTCONF will use alternate relation values to support protocol versioning. [RFC8040] + LinkRelationTypeRestconf | + -- | Identifies a resource that is a reply to the context of the link. [RFC4685] + LinkRelationTypeReplies | + -- | The resource identified by the link target provides an input value to an instance of a rule, where the resource which represents the rule instance is identified by the link context. [OCF Core Optional 2.2.0] + LinkRelationTypeRuleinput | + -- | Refers to a resource that can be used to search through the link's context and related resources. [OpenSearch] + LinkRelationTypeSearch | + -- | Refers to a section in a collection of resources. [HTML 4.01 Specification] + LinkRelationTypeSection | + -- | Conveys an identifier for the link's context. [RFC4287] + LinkRelationTypeSelf | + -- | Indicates a URI that can be used to retrieve a service document. [RFC5023] When used in an Atom document, this relation type specifies Atom Publishing Protocol service documents by default. Requested by James Snell. + LinkRelationTypeService | + -- | Identifies service description for the context that is primarily intended for consumption by machines. [RFC8631] + LinkRelationTypeService_desc | + -- | Identifies service documentation for the context that is primarily intended for human consumption. [RFC8631] + LinkRelationTypeService_doc | + -- | Identifies general metadata for the context that is primarily intended for consumption by machines. [RFC8631] + LinkRelationTypeService_meta | + -- | refers to a capability document that defines parameters or configuration requirements for automated peering and communication channel negotiation of the Session Initiation Protocol (SIP). [draft-engi-siptrunkingcapability-link] + LinkRelationTypeSiptrunkingcapability | + -- | Refers to a resource that is within a context that is sponsored (such as advertising or another compensation agreement). [Google Blog post 09-2019] + LinkRelationTypeSponsored | + -- | Refers to the first resource in a collection of resources. [HTML 4.01 Specification] + LinkRelationTypeStart | + -- | Identifies a resource that represents the context's status. [RFC8631] + LinkRelationTypeStatus | + -- | Refers to a stylesheet. [HTML] + LinkRelationTypeStylesheet | + -- | Refers to a resource serving as a subsection in a collection of resources. [HTML 4.01 Specification] + LinkRelationTypeSubsection | + -- | Points to a resource containing the successor version in the version history. [RFC5829] + LinkRelationTypeSuccessor_version | + -- | Identifies a resource that provides information about the context's retirement policy. [RFC8594] + LinkRelationTypeSunset | + -- | Gives a tag (identified by the given address) that applies to the current document. [HTML] + LinkRelationTypeTag | + -- | Refers to the terms of service associated with the link's context. [RFC6903], section 5 + LinkRelationTypeTerms_of_service | + -- | The Target IRI points to a TimeGate for an Original Resource. [RFC7089] A TimeGate for an Original Resource is a resource that is capable of datetime negotiation to support access to prior states of the Original Resource. + LinkRelationTypeTimegate | + -- | The Target IRI points to a TimeMap for an Original Resource. [RFC7089] A TimeMap for an Original Resource is a resource from which a list of URIs of Mementos of the Original Resource is available. + LinkRelationTypeTimemap | + -- | Refers to a resource identifying the abstract semantic type of which the link's context is considered to be an instance. [RFC6903], section 6 + LinkRelationTypeType | + -- | Refers to a resource that is within a context that is User Generated Content. [Google Blog post 09-2019] + LinkRelationTypeUgc | + -- | Refers to a parent document in a hierarchy of documents. [RFC8288] This relation type registration did not indicate a reference. Requested by Noah Slater. + LinkRelationTypeUp | + -- | Points to a resource containing the version history for the context. [RFC5829] + LinkRelationTypeVersion_history | + -- | Identifies a resource that is the source of the information in the link's context. [RFC4287] + LinkRelationTypeVia | + -- | Identifies a target URI that supports the Webmention protocol. This allows clients that mention a resource in some form of publishing process to contact that endpoint and inform it that this resource has been mentioned. [Webmention] This is a similar "Linkback" mechanism to the ones of Refback, Trackback, and Pingback. It uses a different protocol, though, and thus should be discoverable through its own link relation type. + LinkRelationTypeWebmention | + -- | Points to a working copy for this resource. [RFC5829] + LinkRelationTypeWorking_copy | + -- | Points to the versioned resource from which this working copy was obtained. [RFC5829] + LinkRelationTypeWorking_copy_of + deriving (Eq, Ord, Read, Show) + +_LinkRelationType = Model.Name "hydra.ext.iana.linkrelations.LinkRelationType" + +_LinkRelationType_about = Model.Name "about" + +_LinkRelationType_acl = Model.Name "acl" + +_LinkRelationType_alternate = Model.Name "alternate" + +_LinkRelationType_amphtml = Model.Name "amphtml" + +_LinkRelationType_appendix = Model.Name "appendix" + +_LinkRelationType_apple_touch_icon = Model.Name "apple-touch-icon" + +_LinkRelationType_apple_touch_startup_image = Model.Name "apple-touch-startup-image" + +_LinkRelationType_archives = Model.Name "archives" + +_LinkRelationType_author = Model.Name "author" + +_LinkRelationType_blocked_by = Model.Name "blocked-by" + +_LinkRelationType_bookmark = Model.Name "bookmark" + +_LinkRelationType_canonical = Model.Name "canonical" + +_LinkRelationType_chapter = Model.Name "chapter" + +_LinkRelationType_cite_as = Model.Name "cite-as" + +_LinkRelationType_collection = Model.Name "collection" + +_LinkRelationType_contents = Model.Name "contents" + +_LinkRelationType_convertedfrom = Model.Name "convertedfrom" + +_LinkRelationType_copyright = Model.Name "copyright" + +_LinkRelationType_create_form = Model.Name "create-form" + +_LinkRelationType_current = Model.Name "current" + +_LinkRelationType_describedby = Model.Name "describedby" + +_LinkRelationType_describes = Model.Name "describes" + +_LinkRelationType_disclosure = Model.Name "disclosure" + +_LinkRelationType_dns_prefetch = Model.Name "dns-prefetch" + +_LinkRelationType_duplicate = Model.Name "duplicate" + +_LinkRelationType_edit = Model.Name "edit" + +_LinkRelationType_edit_form = Model.Name "edit-form" + +_LinkRelationType_edit_media = Model.Name "edit-media" + +_LinkRelationType_enclosure = Model.Name "enclosure" + +_LinkRelationType_external = Model.Name "external" + +_LinkRelationType_first = Model.Name "first" + +_LinkRelationType_glossary = Model.Name "glossary" + +_LinkRelationType_help = Model.Name "help" + +_LinkRelationType_hosts = Model.Name "hosts" + +_LinkRelationType_hub = Model.Name "hub" + +_LinkRelationType_icon = Model.Name "icon" + +_LinkRelationType_index = Model.Name "index" + +_LinkRelationType_intervalafter = Model.Name "intervalafter" + +_LinkRelationType_intervalbefore = Model.Name "intervalbefore" + +_LinkRelationType_intervalcontains = Model.Name "intervalcontains" + +_LinkRelationType_intervaldisjoint = Model.Name "intervaldisjoint" + +_LinkRelationType_intervalduring = Model.Name "intervalduring" + +_LinkRelationType_intervalequals = Model.Name "intervalequals" + +_LinkRelationType_intervalfinishedby = Model.Name "intervalfinishedby" + +_LinkRelationType_intervalfinishes = Model.Name "intervalfinishes" + +_LinkRelationType_intervalin = Model.Name "intervalin" + +_LinkRelationType_intervalmeets = Model.Name "intervalmeets" + +_LinkRelationType_intervalmetby = Model.Name "intervalmetby" + +_LinkRelationType_intervaloverlappedby = Model.Name "intervaloverlappedby" + +_LinkRelationType_intervaloverlaps = Model.Name "intervaloverlaps" + +_LinkRelationType_intervalstartedby = Model.Name "intervalstartedby" + +_LinkRelationType_intervalstarts = Model.Name "intervalstarts" + +_LinkRelationType_item = Model.Name "item" + +_LinkRelationType_last = Model.Name "last" + +_LinkRelationType_latest_version = Model.Name "latest-version" + +_LinkRelationType_license = Model.Name "license" + +_LinkRelationType_linkset = Model.Name "linkset" + +_LinkRelationType_lrdd = Model.Name "lrdd" + +_LinkRelationType_manifest = Model.Name "manifest" + +_LinkRelationType_mask_icon = Model.Name "mask-icon" + +_LinkRelationType_media_feed = Model.Name "media-feed" + +_LinkRelationType_memento = Model.Name "memento" + +_LinkRelationType_micropub = Model.Name "micropub" + +_LinkRelationType_modulepreload = Model.Name "modulepreload" + +_LinkRelationType_monitor = Model.Name "monitor" + +_LinkRelationType_monitor_group = Model.Name "monitor-group" + +_LinkRelationType_next = Model.Name "next" + +_LinkRelationType_next_archive = Model.Name "next-archive" + +_LinkRelationType_nofollow = Model.Name "nofollow" + +_LinkRelationType_noopener = Model.Name "noopener" + +_LinkRelationType_noreferrer = Model.Name "noreferrer" + +_LinkRelationType_opener = Model.Name "opener" + +_LinkRelationType_openid2_local_id = Model.Name "openid2.local_id" + +_LinkRelationType_openid2_provider = Model.Name "openid2.provider" + +_LinkRelationType_original = Model.Name "original" + +_LinkRelationType_p3pv1 = Model.Name "p3pv1" + +_LinkRelationType_payment = Model.Name "payment" + +_LinkRelationType_pingback = Model.Name "pingback" + +_LinkRelationType_preconnect = Model.Name "preconnect" + +_LinkRelationType_predecessor_version = Model.Name "predecessor-version" + +_LinkRelationType_prefetch = Model.Name "prefetch" + +_LinkRelationType_preload = Model.Name "preload" + +_LinkRelationType_prerender = Model.Name "prerender" + +_LinkRelationType_prev = Model.Name "prev" + +_LinkRelationType_preview = Model.Name "preview" + +_LinkRelationType_previous = Model.Name "previous" + +_LinkRelationType_prev_archive = Model.Name "prev-archive" + +_LinkRelationType_privacy_policy = Model.Name "privacy-policy" + +_LinkRelationType_profile = Model.Name "profile" + +_LinkRelationType_publication = Model.Name "publication" + +_LinkRelationType_related = Model.Name "related" + +_LinkRelationType_restconf = Model.Name "restconf" + +_LinkRelationType_replies = Model.Name "replies" + +_LinkRelationType_ruleinput = Model.Name "ruleinput" + +_LinkRelationType_search = Model.Name "search" + +_LinkRelationType_section = Model.Name "section" + +_LinkRelationType_self = Model.Name "self" + +_LinkRelationType_service = Model.Name "service" + +_LinkRelationType_service_desc = Model.Name "service-desc" + +_LinkRelationType_service_doc = Model.Name "service-doc" + +_LinkRelationType_service_meta = Model.Name "service-meta" + +_LinkRelationType_siptrunkingcapability = Model.Name "siptrunkingcapability" + +_LinkRelationType_sponsored = Model.Name "sponsored" + +_LinkRelationType_start = Model.Name "start" + +_LinkRelationType_status = Model.Name "status" + +_LinkRelationType_stylesheet = Model.Name "stylesheet" + +_LinkRelationType_subsection = Model.Name "subsection" + +_LinkRelationType_successor_version = Model.Name "successor-version" + +_LinkRelationType_sunset = Model.Name "sunset" + +_LinkRelationType_tag = Model.Name "tag" + +_LinkRelationType_terms_of_service = Model.Name "terms-of-service" + +_LinkRelationType_timegate = Model.Name "timegate" + +_LinkRelationType_timemap = Model.Name "timemap" + +_LinkRelationType_type = Model.Name "type" + +_LinkRelationType_ugc = Model.Name "ugc" + +_LinkRelationType_up = Model.Name "up" + +_LinkRelationType_version_history = Model.Name "version-history" + +_LinkRelationType_via = Model.Name "via" + +_LinkRelationType_webmention = Model.Name "webmention" + +_LinkRelationType_working_copy = Model.Name "working-copy" + +_LinkRelationType_working_copy_of = Model.Name "working-copy-of" diff --git a/src/main/haskell/Hydra/Ext/Json/Schema/Coder.hs b/src/main/haskell/Hydra/Ext/Json/Schema/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Json/Schema/Coder.hs @@ -0,0 +1,292 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | JSON Schema code generator: converts Hydra modules to JSON Schema documents + +module Hydra.Ext.Json.Schema.Coder where + +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Constants as Constants +import qualified Hydra.Core.Dependencies as Dependencies +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Environment as Environment +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Predicates as Predicates +import qualified Hydra.Core.Print.Variants as PrintVariants +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Reflect as Reflect +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variables as Variables +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Json.Schema.Model as SchemaModel +import qualified Hydra.Ext.Json.Schema.Serde as Serde +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M +import qualified Data.Set as S + +-- | Construct JSON Schema documents from type definitions +constructModule :: t0 -> Graph.Graph -> t1 -> [Packaging.TypeDefinition] -> Either Errors.Error (M.Map String SchemaModel.Document) +constructModule cx g mod typeDefs = + + let typeBody = \td -> Model.typeSchemeBody (Packaging.typeDefinitionBody td) + typeMap = Maps.fromList (Lists.map (\td -> (Packaging.typeDefinitionName td, (typeBody td))) typeDefs) + in (Eithers.map (\ps -> Maps.fromList ps) (Eithers.mapList (\td -> typeDefToDocument cx g typeMap (Packaging.typeDefinitionName td) (typeBody td)) typeDefs)) + +-- | Build a single-property record Schema for one branch of an Either oneOf +eitherBranch :: String -> [SchemaModel.Restriction] -> SchemaModel.Schema +eitherBranch label res = + SchemaModel.Schema [ + SchemaModel.RestrictionType (SchemaModel.TypeSingle SchemaModel.TypeNameObject), + (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.singleton (SchemaModel.Keyword label) (SchemaModel.Schema res)))), + (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired [ + SchemaModel.Keyword label])), + (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False)))] + +-- | Encode a field type as a JSON Schema keyword-schema pair +encodeField :: t0 -> Graph.Graph -> Model.FieldType -> Either Errors.Error (SchemaModel.Keyword, SchemaModel.Schema) +encodeField cx g ft = + + let name = Model.fieldTypeName ft + typ = Model.fieldTypeType ft + in (Eithers.map (\res -> (SchemaModel.Keyword (Model.unName name), (SchemaModel.Schema res))) (typeToExpr cx g False typ)) + +-- | Encode a Hydra name as a safe identifier string, replacing non-alphanumeric characters with underscores +encodeName :: Model.Name -> String +encodeName name = Formatting.nonAlnumToUnderscores (Model.unName name) + +-- | Encode a named type as a list of JSON Schema restrictions with a title +encodeNamedType :: t0 -> Graph.Graph -> Model.Name -> Model.Type -> Either Errors.Error [SchemaModel.Restriction] +encodeNamedType cx g name typ = + Eithers.map (\res -> Lists.concat [ + [ + SchemaModel.RestrictionTitle (Model.unName name)], + res]) (typeToExpr cx g False (Strip.deannotateType typ)) + +-- | Encode a record or union as a list of JSON Schema object restrictions; isUnion adds min/maxProperties=1 +encodeRecordOrUnion :: t0 -> Graph.Graph -> Bool -> Bool -> [Model.FieldType] -> Either Errors.Error [SchemaModel.Restriction] +encodeRecordOrUnion cx g optional isUnion fields = + Eithers.bind (Eithers.mapList (\ft -> encodeField cx g ft) fields) (\props -> + let objRes = [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.fromList props))] + reqs = + Lists.foldl (\acc -> \f -> Logic.ifElse (isRequiredField f) (Lists.concat2 acc [ + SchemaModel.Keyword (Model.unName (Model.fieldTypeName f))]) acc) [] fields + reqRes = + Logic.ifElse (Lists.isEmpty reqs) [] [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired reqs)] + addPropsRes = + [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False))] + cardRes = + Logic.ifElse isUnion [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionMinProperties 1), + (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionMaxProperties 1))] [] + in (Right (Lists.concat [ + jsType optional SchemaModel.TypeNameObject, + objRes, + reqRes, + addPropsRes, + cardRes]))) + +-- | Encode a union type, splitting unit-typed (simple) variants into a string-enum branch +encodeUnion :: t0 -> Graph.Graph -> Bool -> [Model.FieldType] -> Either Errors.Error [SchemaModel.Restriction] +encodeUnion cx g optional fields = + + let isSimple = \f -> Predicates.isUnitType (Strip.deannotateType (Model.fieldTypeType f)) + simple = Lists.filter isSimple fields + nonsimple = Lists.filter (\f -> Logic.not (isSimple f)) fields + in (Logic.ifElse (Lists.isEmpty simple) (encodeRecordOrUnion cx g optional True fields) (Eithers.bind (encodeRecordOrUnion cx g False True nonsimple) (\recRes -> + let names = Lists.map (\f -> Model.unName (Model.fieldTypeName f)) simple + simpleSchema = + SchemaModel.Schema [ + SchemaModel.RestrictionType (SchemaModel.TypeSingle SchemaModel.TypeNameString), + (SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionEnum (Lists.map (\n -> JsonModel.ValueString n) names)))] + in (Right [ + SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionOneOf [ + SchemaModel.Schema recRes, + simpleSchema])])))) + +-- | Determine whether a field is required (i.e., not optional/Maybe) +isRequiredField :: Model.FieldType -> Bool +isRequiredField ft = + + let typ = Model.fieldTypeType ft + in case (Strip.deannotateType typ) of + Model.TypeOptional _ -> False + _ -> True + +-- | Build the JSON Schema type-restriction list for a type name, optionally widening to allow null +jsType :: Bool -> SchemaModel.TypeName -> [SchemaModel.Restriction] +jsType optional tname = + [ + SchemaModel.RestrictionType (Logic.ifElse optional (SchemaModel.TypeMultiple [ + tname, + SchemaModel.TypeNameNull]) (SchemaModel.TypeSingle tname))] + +-- | Map a Hydra literal type to a JSON Schema type name. Integer widths beyond the JSON number safe-integer range (int64, uint64, bigint) map to "string", matching the value coder (Hydra.Sources.Json.Encode.encodeInteger), which writes those widths as JSON strings to preserve precision beyond 2^53-1. +literalTypeName :: Model.LiteralType -> SchemaModel.TypeName +literalTypeName lt = + case lt of + Model.LiteralTypeBinary -> SchemaModel.TypeNameString + Model.LiteralTypeBoolean -> SchemaModel.TypeNameBoolean + Model.LiteralTypeFloat _ -> SchemaModel.TypeNameNumber + Model.LiteralTypeInteger v0 -> case v0 of + Model.IntegerTypeBigint -> SchemaModel.TypeNameString + Model.IntegerTypeInt64 -> SchemaModel.TypeNameString + Model.IntegerTypeUint64 -> SchemaModel.TypeNameString + _ -> SchemaModel.TypeNameInteger + Model.LiteralTypeString -> SchemaModel.TypeNameString + _ -> SchemaModel.TypeNameString + +-- | Convert a Hydra module to a map from file path to JSON Schema document string +moduleToJsonSchema :: t0 -> [Packaging.Definition] -> t1 -> Graph.Graph -> Either Errors.Error (M.Map String String) +moduleToJsonSchema mod defs cx g = + + let partitioned = Environment.partitionDefinitions defs + typeDefs = Pairs.first partitioned + in (Eithers.map (\docs -> Maps.map (\doc -> Serde.jsonSchemaDocumentToString doc) docs) (constructModule cx g mod typeDefs)) + +-- | Compute the JSON Schema output file path for a named type +nameToPath :: Model.Name -> String +nameToPath name = + + let qn = Names.qualifyName name + mns = Util.qualifiedNameModuleName qn + local = Util.qualifiedNameLocal qn + nsPart = Optionals.match mns "" (\ns -> Strings.concat2 (Packaging.unModuleName ns) ".") + in (Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "json") (Packaging.ModuleName (Strings.concat2 nsPart local))) + +-- | Build the JSON Schema restriction list for a pair type +pairRestrictions :: Bool -> [SchemaModel.Restriction] -> [SchemaModel.Restriction] -> [SchemaModel.Restriction] +pairRestrictions optional firstRes secondRes = + Lists.concat [ + jsType optional SchemaModel.TypeNameObject, + [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.fromList [ + (SchemaModel.Keyword "first", (SchemaModel.Schema firstRes)), + (SchemaModel.Keyword "second", (SchemaModel.Schema secondRes))]))], + [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired [ + SchemaModel.Keyword "first", + (SchemaModel.Keyword "second")])], + [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False))]] + +-- | Create a JSON Schema reference restriction for a named type +referenceRestriction :: Model.Name -> SchemaModel.Restriction +referenceRestriction name = + SchemaModel.RestrictionReference (SchemaModel.SchemaReference (Strings.concat [ + "#/$defs/", + (encodeName name)])) + +-- | Walk the transitive named-type dependency closure of a root type through typeMap; the visited set guards against cycles in self-/mutually-recursive types +transitiveTypeDeps :: M.Map Model.Name Model.Type -> S.Set Model.Name -> Model.Type -> S.Set Model.Name +transitiveTypeDeps typeMap visited rootType = + + let directDeps = Dependencies.typeDependencyNames True rootType + step = + \acc -> \n -> Logic.ifElse (Sets.member n acc) acc ( + let acc1 = Sets.insert n acc + in (Optionals.match (Maps.lookup n typeMap) acc1 (\t -> transitiveTypeDeps typeMap acc1 t))) + in (Lists.foldl step visited (Sets.toList directDeps)) + +-- | Build a JSON Schema document for a single named type, with $defs covering its transitive dependencies and short-name substitution applied +typeDefToDocument :: t0 -> Graph.Graph -> M.Map Model.Name Model.Type -> Model.Name -> Model.Type -> Either Errors.Error (String, SchemaModel.Document) +typeDefToDocument cx g typeMap rootName rootType = + + let depNames = Sets.toList (transitiveTypeDeps typeMap Sets.empty rootType) + allNames = Lists.concat2 [ + rootName] (Lists.filter (\n -> Logic.not (Equality.equal n rootName)) depNames) + allTypes = Lists.map (\n -> Optionals.withDefault (Model.TypeVariable n) (Maps.lookup n typeMap)) allNames + nameSubst = Dependencies.toShortNames allNames + types = Lists.map (\t -> Variables.substituteTypeVariables nameSubst t) allTypes + names = Lists.map (\n -> Optionals.withDefault n (Maps.lookup n nameSubst)) allNames + subRoot = Optionals.withDefault rootName (Maps.lookup rootName nameSubst) + pairs = Lists.zip names types + in (Eithers.bind (Eithers.mapList (\p -> typeToKeywordSchemaPair cx g (Pairs.first p) (Pairs.second p)) pairs) (\schemas -> Right ( + nameToPath rootName, + SchemaModel.Document { + SchemaModel.documentId = Nothing, + SchemaModel.documentDefinitions = (Just (Maps.fromList schemas)), + SchemaModel.documentRoot = (SchemaModel.Schema [ + referenceRestriction subRoot])}))) + +-- | Encode a Hydra type as a list of JSON Schema restrictions +typeToExpr :: t0 -> Graph.Graph -> Bool -> Model.Type -> Either Errors.Error [SchemaModel.Restriction] +typeToExpr cx g optional typ = + case typ of + Model.TypeAnnotated _ -> Eithers.bind (typeToExpr cx g optional (Strip.deannotateType typ)) (\res -> Eithers.bind (Annotations.getTypeDescription cx g typ) (\mdesc -> Right (Lists.concat2 (Optionals.match mdesc [] (\d -> [ + SchemaModel.RestrictionDescription d])) res))) + Model.TypeApplication v0 -> typeToExpr cx g optional (Model.applicationTypeFunction v0) + Model.TypeEither v0 -> + let lt = Model.eitherTypeLeft v0 + rt = Model.eitherTypeRight v0 + in (Eithers.bind (typeToExpr cx g False lt) (\leftRes -> Eithers.bind (typeToExpr cx g False rt) (\rightRes -> Right [ + SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionOneOf [ + eitherBranch "left" leftRes, + (eitherBranch "right" rightRes)])]))) + Model.TypeForall v0 -> typeToExpr cx g optional (Model.forallTypeBody v0) + Model.TypeList v0 -> Eithers.bind (typeToExpr cx g False v0) (\els -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameArray) [ + SchemaModel.RestrictionArray (SchemaModel.ArrayRestrictionItems (SchemaModel.ItemsSameItems (SchemaModel.Schema els)))])) + Model.TypeLiteral v0 -> Right (jsType optional (literalTypeName v0)) + Model.TypeMap v0 -> + let vt = Model.mapTypeValues v0 + in (Eithers.bind (typeToExpr cx g False vt) (\vRes -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameObject) [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsSchema (SchemaModel.Schema vRes)))]))) + Model.TypeOptional v0 -> typeToExpr cx g True v0 + Model.TypePair v0 -> + let ft = Model.pairTypeFirst v0 + st = Model.pairTypeSecond v0 + in (Eithers.bind (typeToExpr cx g False ft) (\firstRes -> Eithers.bind (typeToExpr cx g False st) (\secondRes -> Right (pairRestrictions optional firstRes secondRes)))) + Model.TypeRecord v0 -> encodeRecordOrUnion cx g optional False v0 + Model.TypeSet v0 -> Eithers.bind (typeToExpr cx g False v0) (\els -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameArray) [ + SchemaModel.RestrictionArray (SchemaModel.ArrayRestrictionItems (SchemaModel.ItemsSameItems (SchemaModel.Schema els)))])) + Model.TypeUnion v0 -> encodeUnion cx g optional v0 + Model.TypeVariable v0 -> Right [ + referenceRestriction v0] + Model.TypeWrap v0 -> typeToExpr cx g optional v0 + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "JSON Schema: unsupported type variant: " (PrintVariants.typeVariant (Reflect.typeVariant typ))))) + +-- | Build a (Keyword, Schema) pair for a named type, used as a $defs entry +typeToKeywordSchemaPair :: t0 -> Graph.Graph -> Model.Name -> Model.Type -> Either Errors.Error (SchemaModel.Keyword, SchemaModel.Schema) +typeToKeywordSchemaPair cx g name typ = + Eithers.map (\res -> (SchemaModel.Keyword (encodeName name), (SchemaModel.Schema res))) (encodeNamedType cx g name typ) diff --git a/src/main/haskell/Hydra/Ext/Json/Schema/Language.hs b/src/main/haskell/Hydra/Ext/Json/Schema/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Json/Schema/Language.hs @@ -0,0 +1,100 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints for JSON Schema + +module Hydra.Ext.Json.Schema.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Reflect as Reflect +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Language constraints for JSON Schema +jsonSchemaLanguage :: Coders.Language +jsonSchemaLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.json.schema"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "json")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = Sets.fromList [ + Model.FloatTypeFloat64] + integerTypes = Sets.fromList [ + Model.IntegerTypeBigint] + termVariants = Sets.fromList Reflect.termVariants + typeVariants = + Sets.fromList [ + Variants.TypeVariantAnnotated, + Variants.TypeVariantApplication, + Variants.TypeVariantEither, + Variants.TypeVariantForall, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantOptional, + Variants.TypeVariantPair, + Variants.TypeVariantRecord, + Variants.TypeVariantSet, + Variants.TypeVariantUnion, + Variants.TypeVariantVariable, + Variants.TypeVariantWrap] + typePredicate = \_ -> True diff --git a/src/main/haskell/Hydra/Ext/Json/Schema/Model.hs b/src/main/haskell/Hydra/Ext/Json/Schema/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Json/Schema/Model.hs @@ -0,0 +1,280 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for JSON Schema. Based on https://cswr.github.io/JsonSchema/spec/grammar + +module Hydra.Ext.Json.Schema.Model where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Whether additional array items beyond those explicitly typed are permitted, and if so, their schema +data AdditionalItems = + AdditionalItemsAny Bool | + AdditionalItemsSchema Schema + deriving (Eq, Ord, Read, Show) + +_AdditionalItems = Model.Name "hydra.ext.json.schema.model.AdditionalItems" + +_AdditionalItems_any = Model.Name "any" + +_AdditionalItems_schema = Model.Name "schema" + +-- | A restriction on array-typed values: items, additionalItems, minItems, maxItems, or uniqueItems +data ArrayRestriction = + ArrayRestrictionItems Items | + ArrayRestrictionAdditionalItems AdditionalItems | + ArrayRestrictionMinItems Int | + ArrayRestrictionMaxItems Int | + ArrayRestrictionUniqueItems Bool + deriving (Eq, Ord, Read, Show) + +_ArrayRestriction = Model.Name "hydra.ext.json.schema.model.ArrayRestriction" + +_ArrayRestriction_items = Model.Name "items" + +_ArrayRestriction_additionalItems = Model.Name "additionalItems" + +_ArrayRestriction_minItems = Model.Name "minItems" + +_ArrayRestriction_maxItems = Model.Name "maxItems" + +_ArrayRestriction_uniqueItems = Model.Name "uniqueItems" + +-- | A JSON Schema document: an optional id, optional local definitions, and a root schema +data Document = + Document { + documentId :: (Maybe String), + documentDefinitions :: (Maybe (M.Map Keyword Schema)), + documentRoot :: Schema} + deriving (Eq, Ord, Read, Show) + +_Document = Model.Name "hydra.ext.json.schema.model.Document" + +_Document_id = Model.Name "id" + +_Document_definitions = Model.Name "definitions" + +_Document_root = Model.Name "root" + +-- | The schema(s) for array items: either a single schema shared by all items, or one schema per item +data Items = + ItemsSameItems Schema | + ItemsVarItems [Schema] + deriving (Eq, Ord, Read, Show) + +_Items = Model.Name "hydra.ext.json.schema.model.Items" + +_Items_sameItems = Model.Name "sameItems" + +_Items_varItems = Model.Name "varItems" + +-- | A property name used as a key in a JSON Schema keyword-to-schema map +newtype Keyword = + Keyword { + unKeyword :: String} + deriving (Eq, Ord, Read, Show) + +_Keyword = Model.Name "hydra.ext.json.schema.model.Keyword" + +-- | A numeric bound with a flag indicating whether the bound itself is excluded +data Limit = + Limit { + limitValue :: Int, + limitExclusive :: Bool} + deriving (Eq, Ord, Read, Show) + +_Limit = Model.Name "hydra.ext.json.schema.model.Limit" + +_Limit_value = Model.Name "value" + +_Limit_exclusive = Model.Name "exclusive" + +-- | A restriction combining multiple schemas: allOf, anyOf, oneOf, not, or enum +data MultipleRestriction = + MultipleRestrictionAllOf [Schema] | + MultipleRestrictionAnyOf [Schema] | + MultipleRestrictionOneOf [Schema] | + MultipleRestrictionNot Schema | + MultipleRestrictionEnum [JsonModel.Value] + deriving (Eq, Ord, Read, Show) + +_MultipleRestriction = Model.Name "hydra.ext.json.schema.model.MultipleRestriction" + +_MultipleRestriction_allOf = Model.Name "allOf" + +_MultipleRestriction_anyOf = Model.Name "anyOf" + +_MultipleRestriction_oneOf = Model.Name "oneOf" + +_MultipleRestriction_not = Model.Name "not" + +_MultipleRestriction_enum = Model.Name "enum" + +-- | A restriction on numeric-typed values: a minimum, a maximum, or a multipleOf constraint +data NumericRestriction = + NumericRestrictionMinimum Limit | + NumericRestrictionMaximum Limit | + NumericRestrictionMultipleOf Int + deriving (Eq, Ord, Read, Show) + +_NumericRestriction = Model.Name "hydra.ext.json.schema.model.NumericRestriction" + +_NumericRestriction_minimum = Model.Name "minimum" + +_NumericRestriction_maximum = Model.Name "maximum" + +_NumericRestriction_multipleOf = Model.Name "multipleOf" + +-- | A restriction on object-typed values: properties, additionalProperties, required, and related keywords +data ObjectRestriction = + ObjectRestrictionProperties (M.Map Keyword Schema) | + ObjectRestrictionAdditionalProperties AdditionalItems | + ObjectRestrictionRequired [Keyword] | + ObjectRestrictionMinProperties Int | + ObjectRestrictionMaxProperties Int | + ObjectRestrictionDependencies (M.Map Keyword SchemaOrArray) | + ObjectRestrictionPatternProperties (M.Map RegularExpression Schema) + deriving (Eq, Ord, Read, Show) + +_ObjectRestriction = Model.Name "hydra.ext.json.schema.model.ObjectRestriction" + +_ObjectRestriction_properties = Model.Name "properties" + +_ObjectRestriction_additionalProperties = Model.Name "additionalProperties" + +_ObjectRestriction_required = Model.Name "required" + +_ObjectRestriction_minProperties = Model.Name "minProperties" + +_ObjectRestriction_maxProperties = Model.Name "maxProperties" + +_ObjectRestriction_dependencies = Model.Name "dependencies" + +_ObjectRestriction_patternProperties = Model.Name "patternProperties" + +-- | A regular expression pattern, as used by the pattern and patternProperties keywords +newtype RegularExpression = + RegularExpression { + unRegularExpression :: String} + deriving (Eq, Ord, Read, Show) + +_RegularExpression = Model.Name "hydra.ext.json.schema.model.RegularExpression" + +-- | A single JSON Schema restriction: a type, value restriction, reference, title, or description +data Restriction = + RestrictionType Type | + RestrictionString StringRestriction | + RestrictionNumber NumericRestriction | + RestrictionArray ArrayRestriction | + RestrictionObject ObjectRestriction | + RestrictionMultiple MultipleRestriction | + RestrictionReference SchemaReference | + RestrictionTitle String | + RestrictionDescription String + deriving (Eq, Ord, Read, Show) + +_Restriction = Model.Name "hydra.ext.json.schema.model.Restriction" + +_Restriction_type = Model.Name "type" + +_Restriction_string = Model.Name "string" + +_Restriction_number = Model.Name "number" + +_Restriction_array = Model.Name "array" + +_Restriction_object = Model.Name "object" + +_Restriction_multiple = Model.Name "multiple" + +_Restriction_reference = Model.Name "reference" + +_Restriction_title = Model.Name "title" + +_Restriction_description = Model.Name "description" + +-- | A JSON schema: a non-empty list of restrictions that a conforming value must satisfy +newtype Schema = + Schema { + unSchema :: [Restriction]} + deriving (Eq, Ord, Read, Show) + +_Schema = Model.Name "hydra.ext.json.schema.model.Schema" + +-- | A dependency value: either a schema, or a list of required keyword names +data SchemaOrArray = + SchemaOrArraySchema Schema | + SchemaOrArrayArray [Keyword] + deriving (Eq, Ord, Read, Show) + +_SchemaOrArray = Model.Name "hydra.ext.json.schema.model.SchemaOrArray" + +_SchemaOrArray_schema = Model.Name "schema" + +_SchemaOrArray_array = Model.Name "array" + +-- | A reference to another schema by URI +newtype SchemaReference = + SchemaReference { + unSchemaReference :: String} + deriving (Eq, Ord, Read, Show) + +_SchemaReference = Model.Name "hydra.ext.json.schema.model.SchemaReference" + +-- | A restriction on string-typed values: minLength, maxLength, or pattern +data StringRestriction = + StringRestrictionMinLength Int | + StringRestrictionMaxLength Int | + StringRestrictionPattern RegularExpression + deriving (Eq, Ord, Read, Show) + +_StringRestriction = Model.Name "hydra.ext.json.schema.model.StringRestriction" + +_StringRestriction_minLength = Model.Name "minLength" + +_StringRestriction_maxLength = Model.Name "maxLength" + +_StringRestriction_pattern = Model.Name "pattern" + +-- | A type restriction: a single type name, or a list of alternative type names +data Type = + TypeSingle TypeName | + TypeMultiple [TypeName] + deriving (Eq, Ord, Read, Show) + +_Type = Model.Name "hydra.ext.json.schema.model.Type" + +_Type_single = Model.Name "single" + +_Type_multiple = Model.Name "multiple" + +-- | The name of a JSON Schema primitive type +data TypeName = + TypeNameString | + TypeNameInteger | + TypeNameNumber | + TypeNameBoolean | + TypeNameNull | + TypeNameArray | + TypeNameObject + deriving (Eq, Ord, Read, Show) + +_TypeName = Model.Name "hydra.ext.json.schema.model.TypeName" + +_TypeName_string = Model.Name "string" + +_TypeName_integer = Model.Name "integer" + +_TypeName_number = Model.Name "number" + +_TypeName_boolean = Model.Name "boolean" + +_TypeName_null = Model.Name "null" + +_TypeName_array = Model.Name "array" + +_TypeName_object = Model.Name "object" diff --git a/src/main/haskell/Hydra/Ext/Json/Schema/Serde.hs b/src/main/haskell/Hydra/Ext/Json/Schema/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Json/Schema/Serde.hs @@ -0,0 +1,386 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Serialization functions for converting JSON Schema documents to JSON values + +module Hydra.Ext.Json.Schema.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Json.Writer as Writer +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Json.Schema.Model as SchemaModel +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Encode additional items as a JSON value +additionalItemsToExpr :: SchemaModel.AdditionalItems -> JsonModel.Value +additionalItemsToExpr ai = + case ai of + SchemaModel.AdditionalItemsAny v0 -> JsonModel.ValueBoolean v0 + SchemaModel.AdditionalItemsSchema v0 -> schemaToExpr v0 + +-- | Encode an array restriction as a key-value pair +arrayRestrictionToExpr :: SchemaModel.ArrayRestriction -> (String, JsonModel.Value) +arrayRestrictionToExpr r = + case r of + SchemaModel.ArrayRestrictionItems v0 -> itemsToExpr v0 + SchemaModel.ArrayRestrictionAdditionalItems v0 -> (keyAdditionalItems, (additionalItemsToExpr v0)) + SchemaModel.ArrayRestrictionMinItems v0 -> (keyMinItems, (integerToExpr v0)) + SchemaModel.ArrayRestrictionMaxItems v0 -> (keyMaxItems, (integerToExpr v0)) + SchemaModel.ArrayRestrictionUniqueItems v0 -> (keyUniqueItems, (JsonModel.ValueBoolean v0)) + +-- | Extract a name-keyed map from a JSON object value (field order is dropped) +fromObject :: JsonModel.Value -> M.Map String JsonModel.Value +fromObject v = + case v of + JsonModel.ValueObject v0 -> Maps.fromList v0 + +-- | Encode an integer as a JSON number value +integerToExpr :: Int -> JsonModel.Value +integerToExpr n = JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint n)) + +-- | Encode items as a key-value pair +itemsToExpr :: SchemaModel.Items -> (String, JsonModel.Value) +itemsToExpr items = + ( + keyItems, + case items of + SchemaModel.ItemsSameItems v0 -> schemaToExpr v0 + SchemaModel.ItemsVarItems v0 -> JsonModel.ValueArray (Lists.map schemaToExpr v0)) + +-- | Convert a JSON Schema document to a JSON value +jsonSchemaDocumentToJsonValue :: SchemaModel.Document -> JsonModel.Value +jsonSchemaDocumentToJsonValue doc = + + let mid = SchemaModel.documentId doc + mdefs = SchemaModel.documentDefinitions doc + root = SchemaModel.documentRoot doc + schemaMap = fromObject (schemaToExpr root) + restMap = + fromObject (toObject [ + (keyId, (Optionals.map (\i -> JsonModel.ValueString i) mid)), + (keySchema, (Optionals.given (JsonModel.ValueString "http://json-schema.org/2020-12/schema"))), + ( + keyDefinitions, + (Optionals.map (\mp -> JsonModel.ValueObject (Lists.map (\p -> + let k = Pairs.first p + schema = Pairs.second p + in (SchemaModel.unKeyword k, (schemaToExpr schema))) (Maps.toList mp))) mdefs))]) + in (JsonModel.ValueObject (Maps.toList (Maps.union schemaMap restMap))) + +-- | Convert a JSON Schema document to a JSON string +jsonSchemaDocumentToString :: SchemaModel.Document -> String +jsonSchemaDocumentToString doc = Writer.printJson (jsonSchemaDocumentToJsonValue doc) + +-- | The JSON Schema "additionalItems" keyword +keyAdditionalItems :: String +keyAdditionalItems = "additionalItems" + +-- | The JSON Schema "additionalProperties" keyword +keyAdditionalProperties :: String +keyAdditionalProperties = "additionalProperties" + +-- | The JSON Schema "allOf" keyword +keyAllOf :: String +keyAllOf = "allOf" + +-- | The JSON Schema "anyOf" keyword +keyAnyOf :: String +keyAnyOf = "anyOf" + +-- | The JSON Schema "$defs" keyword, used for reusable schema definitions +keyDefinitions :: String +keyDefinitions = "$defs" + +-- | The JSON Schema "dependencies" keyword +keyDependencies :: String +keyDependencies = "dependencies" + +-- | The JSON Schema "description" keyword +keyDescription :: String +keyDescription = "description" + +-- | The JSON Schema "enum" keyword +keyEnum :: String +keyEnum = "enum" + +-- | The JSON Schema "exclusiveMaximum" keyword +keyExclusiveMaximum :: String +keyExclusiveMaximum = "exclusiveMaximum" + +-- | The JSON Schema "exclusiveMinimum" keyword +keyExclusiveMinimum :: String +keyExclusiveMinimum = "exclusiveMinimum" + +-- | The JSON Schema "$id" keyword, identifying the schema +keyId :: String +keyId = "$id" + +-- | The JSON Schema "items" keyword +keyItems :: String +keyItems = "items" + +-- | The JSON Schema "label" keyword +keyLabel :: String +keyLabel = "label" + +-- | The JSON Schema "maxItems" keyword +keyMaxItems :: String +keyMaxItems = "maxItems" + +-- | The JSON Schema "maxLength" keyword +keyMaxLength :: String +keyMaxLength = "maxLength" + +-- | The JSON Schema "maxProperties" keyword +keyMaxProperties :: String +keyMaxProperties = "maxProperties" + +-- | The JSON Schema "maximum" keyword +keyMaximum :: String +keyMaximum = "maximum" + +-- | The JSON Schema "minItems" keyword +keyMinItems :: String +keyMinItems = "minItems" + +-- | The JSON Schema "minLength" keyword +keyMinLength :: String +keyMinLength = "minLength" + +-- | The JSON Schema "minProperties" keyword +keyMinProperties :: String +keyMinProperties = "minProperties" + +-- | The JSON Schema "minimum" keyword +keyMinimum :: String +keyMinimum = "minimum" + +-- | The JSON Schema "multipleOf" keyword +keyMultipleOf :: String +keyMultipleOf = "multipleOf" + +-- | The JSON Schema "not" keyword +keyNot :: String +keyNot = "not" + +-- | The JSON Schema "oneOf" keyword +keyOneOf :: String +keyOneOf = "oneOf" + +-- | The JSON Schema "pattern" keyword +keyPattern :: String +keyPattern = "pattern" + +-- | The JSON Schema "patternProperties" keyword +keyPatternProperties :: String +keyPatternProperties = "patternProperties" + +-- | The JSON Schema "properties" keyword +keyProperties :: String +keyProperties = "properties" + +-- | The JSON Schema "$ref" keyword, used for schema references +keyRef :: String +keyRef = "$ref" + +-- | The JSON Schema "required" keyword +keyRequired :: String +keyRequired = "required" + +-- | The JSON Schema "$schema" keyword, identifying the schema dialect +keySchema :: String +keySchema = "$schema" + +-- | The JSON Schema "title" keyword +keyTitle :: String +keyTitle = "title" + +-- | The JSON Schema "type" keyword +keyType :: String +keyType = "type" + +-- | The JSON Schema "uniqueItems" keyword +keyUniqueItems :: String +keyUniqueItems = "uniqueItems" + +-- | Encode a keyword-schema-or-array pair as a key-value pair +keywordSchemaOrArrayToExpr :: (SchemaModel.Keyword, SchemaModel.SchemaOrArray) -> (String, JsonModel.Value) +keywordSchemaOrArrayToExpr p = + + let k = Pairs.first p + s = Pairs.second p + in (SchemaModel.unKeyword k, (schemaOrArrayToExpr s)) + +-- | Encode a keyword as a JSON string value +keywordToExpr :: SchemaModel.Keyword -> JsonModel.Value +keywordToExpr k = JsonModel.ValueString (SchemaModel.unKeyword k) + +-- | Encode a multiple restriction as a key-value pair +multipleRestrictionToExpr :: SchemaModel.MultipleRestriction -> (String, JsonModel.Value) +multipleRestrictionToExpr r = + case r of + SchemaModel.MultipleRestrictionAllOf v0 -> (keyAllOf, (JsonModel.ValueArray (Lists.map schemaToExpr v0))) + SchemaModel.MultipleRestrictionAnyOf v0 -> (keyAnyOf, (JsonModel.ValueArray (Lists.map schemaToExpr v0))) + SchemaModel.MultipleRestrictionOneOf v0 -> (keyOneOf, (JsonModel.ValueArray (Lists.map schemaToExpr v0))) + SchemaModel.MultipleRestrictionNot v0 -> (keyNot, (schemaToExpr v0)) + SchemaModel.MultipleRestrictionEnum v0 -> (keyEnum, (JsonModel.ValueArray v0)) + +-- | Encode a numeric restriction as a list of key-value pairs +numericRestrictionToExpr :: SchemaModel.NumericRestriction -> [(String, JsonModel.Value)] +numericRestrictionToExpr r = + case r of + SchemaModel.NumericRestrictionMinimum v0 -> + let value = SchemaModel.limitValue v0 + excl = SchemaModel.limitExclusive v0 + in (Lists.concat [ + [ + (keyMinimum, (integerToExpr value))], + (Logic.ifElse excl [ + (keyExclusiveMinimum, (JsonModel.ValueBoolean True))] [])]) + SchemaModel.NumericRestrictionMaximum v0 -> + let value = SchemaModel.limitValue v0 + excl = SchemaModel.limitExclusive v0 + in (Lists.concat [ + [ + (keyMaximum, (integerToExpr value))], + (Logic.ifElse excl [ + (keyExclusiveMaximum, (JsonModel.ValueBoolean True))] [])]) + SchemaModel.NumericRestrictionMultipleOf v0 -> [ + (keyMultipleOf, (integerToExpr v0))] + +-- | Encode an object restriction as a key-value pair +objectRestrictionToExpr :: SchemaModel.ObjectRestriction -> (String, JsonModel.Value) +objectRestrictionToExpr r = + case r of + SchemaModel.ObjectRestrictionProperties v0 -> (keyProperties, (JsonModel.ValueObject (Lists.map propertyToExpr (Maps.toList v0)))) + SchemaModel.ObjectRestrictionAdditionalProperties v0 -> (keyAdditionalProperties, (additionalItemsToExpr v0)) + SchemaModel.ObjectRestrictionRequired v0 -> (keyRequired, (JsonModel.ValueArray (Lists.map keywordToExpr v0))) + SchemaModel.ObjectRestrictionMinProperties v0 -> (keyMinProperties, (integerToExpr v0)) + SchemaModel.ObjectRestrictionMaxProperties v0 -> (keyMaxProperties, (integerToExpr v0)) + SchemaModel.ObjectRestrictionDependencies v0 -> (keyDependencies, (JsonModel.ValueObject (Lists.map keywordSchemaOrArrayToExpr (Maps.toList v0)))) + SchemaModel.ObjectRestrictionPatternProperties v0 -> (keyPatternProperties, (JsonModel.ValueObject (Lists.map patternPropertyToExpr (Maps.toList v0)))) + +-- | Encode a pattern property pair as a key-value pair +patternPropertyToExpr :: (SchemaModel.RegularExpression, SchemaModel.Schema) -> (String, JsonModel.Value) +patternPropertyToExpr p = + + let pat = Pairs.first p + s = Pairs.second p + in (SchemaModel.unRegularExpression pat, (schemaToExpr s)) + +-- | Encode a property pair as a key-value pair +propertyToExpr :: (SchemaModel.Keyword, SchemaModel.Schema) -> (String, JsonModel.Value) +propertyToExpr p = + + let k = Pairs.first p + s = Pairs.second p + in (SchemaModel.unKeyword k, (schemaToExpr s)) + +-- | Encode a restriction as a list of key-value pairs +restrictionToExpr :: SchemaModel.Restriction -> [(String, JsonModel.Value)] +restrictionToExpr r = + case r of + SchemaModel.RestrictionType v0 -> [ + (keyType, (typeToExpr v0))] + SchemaModel.RestrictionString v0 -> [ + stringRestrictionToExpr v0] + SchemaModel.RestrictionNumber v0 -> numericRestrictionToExpr v0 + SchemaModel.RestrictionArray v0 -> [ + arrayRestrictionToExpr v0] + SchemaModel.RestrictionObject v0 -> [ + objectRestrictionToExpr v0] + SchemaModel.RestrictionMultiple v0 -> [ + multipleRestrictionToExpr v0] + SchemaModel.RestrictionReference v0 -> [ + (keyRef, (schemaReferenceToExpr v0))] + SchemaModel.RestrictionTitle v0 -> [ + (keyTitle, (JsonModel.ValueString v0))] + SchemaModel.RestrictionDescription v0 -> [ + (keyDescription, (JsonModel.ValueString v0))] + +-- | Encode a schema or array as a JSON value +schemaOrArrayToExpr :: SchemaModel.SchemaOrArray -> JsonModel.Value +schemaOrArrayToExpr soa = + case soa of + SchemaModel.SchemaOrArraySchema v0 -> schemaToExpr v0 + SchemaModel.SchemaOrArrayArray v0 -> JsonModel.ValueArray (Lists.map keywordToExpr v0) + +-- | Encode a schema reference as a JSON string value +schemaReferenceToExpr :: SchemaModel.SchemaReference -> JsonModel.Value +schemaReferenceToExpr sr = JsonModel.ValueString (SchemaModel.unSchemaReference sr) + +-- | Encode a schema as a JSON object value +schemaToExpr :: SchemaModel.Schema -> JsonModel.Value +schemaToExpr s = JsonModel.ValueObject (Lists.concat (Lists.map restrictionToExpr (SchemaModel.unSchema s))) + +-- | Encode a string restriction as a key-value pair +stringRestrictionToExpr :: SchemaModel.StringRestriction -> (String, JsonModel.Value) +stringRestrictionToExpr r = + case r of + SchemaModel.StringRestrictionMaxLength v0 -> (keyMaxLength, (JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint v0)))) + SchemaModel.StringRestrictionMinLength v0 -> (keyMinLength, (JsonModel.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint v0)))) + SchemaModel.StringRestrictionPattern v0 -> (keyPattern, (JsonModel.ValueString (SchemaModel.unRegularExpression v0))) + +-- | Construct a JSON object from a list of optional key-value pairs, filtering out Nothing values +toObject :: [(String, (Maybe JsonModel.Value))] -> JsonModel.Value +toObject pairs = + JsonModel.ValueObject (Optionals.givens (Lists.map (\p -> + let k = Pairs.first p + mv = Pairs.second p + in (Optionals.map (\v -> (k, v)) mv)) pairs)) + +-- | Encode a type name as a JSON string value +typeNameToExpr :: SchemaModel.TypeName -> JsonModel.Value +typeNameToExpr t = + case t of + SchemaModel.TypeNameString -> JsonModel.ValueString "string" + SchemaModel.TypeNameInteger -> JsonModel.ValueString "integer" + SchemaModel.TypeNameNumber -> JsonModel.ValueString "number" + SchemaModel.TypeNameBoolean -> JsonModel.ValueString "boolean" + SchemaModel.TypeNameNull -> JsonModel.ValueString "null" + SchemaModel.TypeNameArray -> JsonModel.ValueString "array" + SchemaModel.TypeNameObject -> JsonModel.ValueString "object" + +-- | Encode a type as a JSON value +typeToExpr :: SchemaModel.Type -> JsonModel.Value +typeToExpr t = + case t of + SchemaModel.TypeSingle v0 -> typeNameToExpr v0 + SchemaModel.TypeMultiple v0 -> JsonModel.ValueArray (Lists.map typeNameToExpr v0) diff --git a/src/main/haskell/Hydra/Ext/Kusto/Kql.hs b/src/main/haskell/Hydra/Ext/Kusto/Kql.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Kusto/Kql.hs @@ -0,0 +1,737 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A partial KQL (Kusto Query Language) model, based on examples from the documentation. Not normative. + +module Hydra.Ext.Kusto.Kql where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Int as I + +-- | A 'between' range test on an expression, optionally negated +data BetweenExpression = + BetweenExpression { + betweenExpressionNot :: Bool, + betweenExpressionExpression :: Expression, + betweenExpressionLowerBound :: Expression, + betweenExpressionUpperBound :: Expression} + deriving (Eq, Ord, Read, Show) + +_BetweenExpression = Model.Name "hydra.ext.kusto.kql.BetweenExpression" + +_BetweenExpression_not = Model.Name "not" + +_BetweenExpression_expression = Model.Name "expression" + +_BetweenExpression_lowerBound = Model.Name "lowerBound" + +_BetweenExpression_upperBound = Model.Name "upperBound" + +-- | A binary operator expression, combining a left and right operand +data BinaryExpression = + BinaryExpression { + binaryExpressionLeft :: Expression, + binaryExpressionOperator :: BinaryOperator, + binaryExpressionRight :: Expression} + deriving (Eq, Ord, Read, Show) + +_BinaryExpression = Model.Name "hydra.ext.kusto.kql.BinaryExpression" + +_BinaryExpression_left = Model.Name "left" + +_BinaryExpression_operator = Model.Name "operator" + +_BinaryExpression_right = Model.Name "right" + +-- | A binary comparison or arithmetic operator used in KQL expressions +data BinaryOperator = + BinaryOperatorCaseInsensitiveEqual | + BinaryOperatorContains | + BinaryOperatorDivide | + BinaryOperatorEndsWith | + BinaryOperatorEqual | + BinaryOperatorGreater | + BinaryOperatorGreaterOrEqual | + BinaryOperatorHas | + BinaryOperatorHasPrefix | + BinaryOperatorHasSuffix | + BinaryOperatorLess | + BinaryOperatorLessOrEqual | + BinaryOperatorMatchesRegex | + BinaryOperatorMinus | + BinaryOperatorNotEqual | + BinaryOperatorPlus | + BinaryOperatorStartsWith | + BinaryOperatorTimes + deriving (Eq, Ord, Read, Show) + +_BinaryOperator = Model.Name "hydra.ext.kusto.kql.BinaryOperator" + +_BinaryOperator_caseInsensitiveEqual = Model.Name "caseInsensitiveEqual" + +_BinaryOperator_contains = Model.Name "contains" + +_BinaryOperator_divide = Model.Name "divide" + +_BinaryOperator_endsWith = Model.Name "endsWith" + +_BinaryOperator_equal = Model.Name "equal" + +_BinaryOperator_greater = Model.Name "greater" + +_BinaryOperator_greaterOrEqual = Model.Name "greaterOrEqual" + +_BinaryOperator_has = Model.Name "has" + +_BinaryOperator_hasPrefix = Model.Name "hasPrefix" + +_BinaryOperator_hasSuffix = Model.Name "hasSuffix" + +_BinaryOperator_less = Model.Name "less" + +_BinaryOperator_lessOrEqual = Model.Name "lessOrEqual" + +_BinaryOperator_matchesRegex = Model.Name "matchesRegex" + +_BinaryOperator_minus = Model.Name "minus" + +_BinaryOperator_notEqual = Model.Name "notEqual" + +_BinaryOperator_plus = Model.Name "plus" + +_BinaryOperator_startsWith = Model.Name "startsWith" + +_BinaryOperator_times = Model.Name "times" + +-- | One of the built-in scalar or aggregation functions supported by KQL +data BuiltInFunction = + BuiltInFunctionAgo | + BuiltInFunctionBin | + BuiltInFunctionCount | + BuiltInFunctionDcount | + BuiltInFunctionEndofday | + BuiltInFunctionExtract | + BuiltInFunctionFormat_datetime | + BuiltInFunctionMaterialize | + BuiltInFunctionNow | + BuiltInFunctionRange | + BuiltInFunctionStartofday | + BuiltInFunctionStrcat | + BuiltInFunctionTodynamic + deriving (Eq, Ord, Read, Show) + +_BuiltInFunction = Model.Name "hydra.ext.kusto.kql.BuiltInFunction" + +_BuiltInFunction_ago = Model.Name "ago" + +_BuiltInFunction_bin = Model.Name "bin" + +_BuiltInFunction_count = Model.Name "count" + +_BuiltInFunction_dcount = Model.Name "dcount" + +_BuiltInFunction_endofday = Model.Name "endofday" + +_BuiltInFunction_extract = Model.Name "extract" + +_BuiltInFunction_format_datetime = Model.Name "format_datetime" + +_BuiltInFunction_materialize = Model.Name "materialize" + +_BuiltInFunction_now = Model.Name "now" + +_BuiltInFunction_range = Model.Name "range" + +_BuiltInFunction_startofday = Model.Name "startofday" + +_BuiltInFunction_strcat = Model.Name "strcat" + +_BuiltInFunction_todynamic = Model.Name "todynamic" + +-- | An association between a column and an alternate (renamed) column name +data ColumnAlias = + ColumnAlias { + columnAliasColumn :: ColumnName, + columnAliasAlias :: ColumnName} + deriving (Eq, Ord, Read, Show) + +_ColumnAlias = Model.Name "hydra.ext.kusto.kql.ColumnAlias" + +_ColumnAlias_column = Model.Name "column" + +_ColumnAlias_alias = Model.Name "alias" + +-- | An assignment of a computed expression to a column +data ColumnAssignment = + ColumnAssignment { + columnAssignmentColumn :: ColumnName, + columnAssignmentExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_ColumnAssignment = Model.Name "hydra.ext.kusto.kql.ColumnAssignment" + +_ColumnAssignment_column = Model.Name "column" + +_ColumnAssignment_expression = Model.Name "expression" + +-- | The name of a table column +newtype ColumnName = + ColumnName { + unColumnName :: String} + deriving (Eq, Ord, Read, Show) + +_ColumnName = Model.Name "hydra.ext.kusto.kql.ColumnName" + +-- | A selection of either all columns, or a single named column +data Columns = + ColumnsAll | + ColumnsSingle ColumnName + deriving (Eq, Ord, Read, Show) + +_Columns = Model.Name "hydra.ext.kusto.kql.Columns" + +_Columns_all = Model.Name "all" + +_Columns_single = Model.Name "single" + +-- | A tabular operator, applied in sequence within a pipeline expression +data Command = + CommandCount | + -- | See https://learn.microsoft.com/en-us/azure/data-explorer/kusto/query/distinct-operator + CommandDistinct [ColumnName] | + CommandExtend [ColumnAssignment] | + CommandJoin JoinCommand | + CommandLimit Int | + CommandMvexpand ColumnName | + CommandOrderBy [SortBy] | + CommandParse ParseCommand | + CommandPrint PrintCommand | + CommandProject [Projection] | + CommandProjectAway [ColumnName] | + CommandProjectRename [ColumnAlias] | + CommandRender String | + CommandSearch SearchCommand | + CommandSortBy [SortBy] | + CommandSummarize SummarizeCommand | + -- | Limit a search to a specified number of results + CommandTake Int | + CommandTop TopCommand | + CommandUnion UnionCommand | + CommandWhere Expression + deriving (Eq, Ord, Read, Show) + +_Command = Model.Name "hydra.ext.kusto.kql.Command" + +_Command_count = Model.Name "count" + +_Command_distinct = Model.Name "distinct" + +_Command_extend = Model.Name "extend" + +_Command_join = Model.Name "join" + +_Command_limit = Model.Name "limit" + +_Command_mvexpand = Model.Name "mvexpand" + +_Command_orderBy = Model.Name "orderBy" + +_Command_parse = Model.Name "parse" + +_Command_print = Model.Name "print" + +_Command_project = Model.Name "project" + +_Command_projectAway = Model.Name "projectAway" + +_Command_projectRename = Model.Name "projectRename" + +_Command_render = Model.Name "render" + +_Command_search = Model.Name "search" + +_Command_sortBy = Model.Name "sortBy" + +_Command_summarize = Model.Name "summarize" + +_Command_take = Model.Name "take" + +_Command_top = Model.Name "top" + +_Command_union = Model.Name "union" + +_Command_where = Model.Name "where" + +-- | A KQL datetime literal +newtype Datetime = + Datetime { + unDatetime :: String} + deriving (Eq, Ord, Read, Show) + +_Datetime = Model.Name "hydra.ext.kusto.kql.Datetime" + +-- | A duration (timespan) literal, expressed as a value and a unit +data Duration = + Duration { + durationValue :: Int, + durationUnit :: DurationUnit} + deriving (Eq, Ord, Read, Show) + +_Duration = Model.Name "hydra.ext.kusto.kql.Duration" + +_Duration_value = Model.Name "value" + +_Duration_unit = Model.Name "unit" + +-- | The unit of measure of a Duration value +data DurationUnit = + DurationUnitSecond | + DurationUnitMinute | + DurationUnitHour + deriving (Eq, Ord, Read, Show) + +_DurationUnit = Model.Name "hydra.ext.kusto.kql.DurationUnit" + +_DurationUnit_second = Model.Name "second" + +_DurationUnit_minute = Model.Name "minute" + +_DurationUnit_hour = Model.Name "hour" + +-- | A KQL scalar expression +data Expression = + ExpressionAnd [Expression] | + ExpressionAny | + ExpressionBetween BetweenExpression | + ExpressionBinary BinaryExpression | + ExpressionBraces Expression | + ExpressionColumn ColumnName | + ExpressionDataset TableName | + ExpressionIndex IndexExpression | + ExpressionList [Expression] | + ExpressionLiteral Literal | + ExpressionOr [Expression] | + ExpressionParentheses Expression | + ExpressionProperty PropertyExpression | + ExpressionUnary UnaryExpression + deriving (Eq, Ord, Read, Show) + +_Expression = Model.Name "hydra.ext.kusto.kql.Expression" + +_Expression_and = Model.Name "and" + +_Expression_any = Model.Name "any" + +_Expression_between = Model.Name "between" + +_Expression_binary = Model.Name "binary" + +_Expression_braces = Model.Name "braces" + +_Expression_column = Model.Name "column" + +_Expression_dataset = Model.Name "dataset" + +_Expression_index = Model.Name "index" + +_Expression_list = Model.Name "list" + +_Expression_literal = Model.Name "literal" + +_Expression_or = Model.Name "or" + +_Expression_parentheses = Model.Name "parentheses" + +_Expression_property = Model.Name "property" + +_Expression_unary = Model.Name "unary" + +-- | A reference to either a built-in or a user-defined function +data Function = + FunctionBuiltIn BuiltInFunction | + FunctionCustom FunctionName + deriving (Eq, Ord, Read, Show) + +_Function = Model.Name "hydra.ext.kusto.kql.Function" + +_Function_builtIn = Model.Name "builtIn" + +_Function_custom = Model.Name "custom" + +-- | An invocation of a function with a list of argument expressions +data FunctionExpression = + FunctionExpression { + functionExpressionFunction :: Function, + functionExpressionArguments :: [Expression]} + deriving (Eq, Ord, Read, Show) + +_FunctionExpression = Model.Name "hydra.ext.kusto.kql.FunctionExpression" + +_FunctionExpression_function = Model.Name "function" + +_FunctionExpression_arguments = Model.Name "arguments" + +-- | The name of a user-defined function +newtype FunctionName = + FunctionName { + unFunctionName :: String} + deriving (Eq, Ord, Read, Show) + +_FunctionName = Model.Name "hydra.ext.kusto.kql.FunctionName" + +-- | An indexing operation applied to an expression, e.g. array or property access +data IndexExpression = + IndexExpression { + indexExpressionExpression :: Expression, + indexExpressionIndex :: String} + deriving (Eq, Ord, Read, Show) + +_IndexExpression = Model.Name "hydra.ext.kusto.kql.IndexExpression" + +_IndexExpression_expression = Model.Name "expression" + +_IndexExpression_index = Model.Name "index" + +-- | A 'join' operator combining rows from the current and a second tabular expression +data JoinCommand = + JoinCommand { + joinCommandKind :: JoinKind, + joinCommandExpression :: TableName, + joinCommandOn :: Expression} + deriving (Eq, Ord, Read, Show) + +_JoinCommand = Model.Name "hydra.ext.kusto.kql.JoinCommand" + +_JoinCommand_kind = Model.Name "kind" + +_JoinCommand_expression = Model.Name "expression" + +_JoinCommand_on = Model.Name "on" + +-- | The kind of join to perform, e.g. inner, left outer, or left semi/anti +data JoinKind = + JoinKindLeftouter | + JoinKindLeftsemi | + JoinKindLeftanti | + JoinKindFullouter | + JoinKindInner | + JoinKindInnerunique | + JoinKindRightouter | + JoinKindRightsemi | + JoinKindRightanti + deriving (Eq, Ord, Read, Show) + +_JoinKind = Model.Name "hydra.ext.kusto.kql.JoinKind" + +_JoinKind_leftouter = Model.Name "leftouter" + +_JoinKind_leftsemi = Model.Name "leftsemi" + +_JoinKind_leftanti = Model.Name "leftanti" + +_JoinKind_fullouter = Model.Name "fullouter" + +_JoinKind_inner = Model.Name "inner" + +_JoinKind_innerunique = Model.Name "innerunique" + +_JoinKind_rightouter = Model.Name "rightouter" + +_JoinKind_rightsemi = Model.Name "rightsemi" + +_JoinKind_rightanti = Model.Name "rightanti" + +-- | A key-value pair extracted by a 'parse' command +data KeyValuePair = + KeyValuePair { + keyValuePairKey :: String, + keyValuePairValue :: Expression} + deriving (Eq, Ord, Read, Show) + +_KeyValuePair = Model.Name "hydra.ext.kusto.kql.KeyValuePair" + +_KeyValuePair_key = Model.Name "key" + +_KeyValuePair_value = Model.Name "value" + +-- | A single 'let' binding of a name to an expression +data LetBinding = + LetBinding { + letBindingName :: ColumnName, + letBindingExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_LetBinding = Model.Name "hydra.ext.kusto.kql.LetBinding" + +_LetBinding_name = Model.Name "name" + +_LetBinding_expression = Model.Name "expression" + +-- | A sequence of 'let' bindings followed by a tabular expression that may reference them +data LetExpression = + LetExpression { + letExpressionBindings :: [LetBinding], + letExpressionExpression :: TabularExpression} + deriving (Eq, Ord, Read, Show) + +_LetExpression = Model.Name "hydra.ext.kusto.kql.LetExpression" + +_LetExpression_bindings = Model.Name "bindings" + +_LetExpression_expression = Model.Name "expression" + +-- | A literal value in a KQL expression +data Literal = + LiteralDuration Duration | + LiteralDatetime Datetime | + LiteralString String | + LiteralInt Int | + LiteralLong I.Int64 | + LiteralDouble Double | + LiteralBoolean Bool + deriving (Eq, Ord, Read, Show) + +_Literal = Model.Name "hydra.ext.kusto.kql.Literal" + +_Literal_duration = Model.Name "duration" + +_Literal_datetime = Model.Name "datetime" + +_Literal_string = Model.Name "string" + +_Literal_int = Model.Name "int" + +_Literal_long = Model.Name "long" + +_Literal_double = Model.Name "double" + +_Literal_boolean = Model.Name "boolean" + +-- | The sort direction for an 'order by' or 'sort by' clause +data Order = + OrderAscending | + OrderDescending + deriving (Eq, Ord, Read, Show) + +_Order = Model.Name "hydra.ext.kusto.kql.Order" + +_Order_ascending = Model.Name "ascending" + +_Order_descending = Model.Name "descending" + +-- | A named parameter with a literal value, e.g. for a union operator +data Parameter = + Parameter { + parameterKey :: String, + parameterValue :: Literal} + deriving (Eq, Ord, Read, Show) + +_Parameter = Model.Name "hydra.ext.kusto.kql.Parameter" + +_Parameter_key = Model.Name "key" + +_Parameter_value = Model.Name "value" + +-- | A 'parse' command that extracts key-value pairs from a column into new columns +data ParseCommand = + ParseCommand { + parseCommandColumn :: ColumnName, + parseCommandPairs :: [KeyValuePair]} + deriving (Eq, Ord, Read, Show) + +_ParseCommand = Model.Name "hydra.ext.kusto.kql.ParseCommand" + +_ParseCommand_column = Model.Name "column" + +_ParseCommand_pairs = Model.Name "pairs" + +-- | A pipe ('|')-separated sequence of tabular expressions +newtype PipelineExpression = + PipelineExpression { + unPipelineExpression :: [TabularExpression]} + deriving (Eq, Ord, Read, Show) + +_PipelineExpression = Model.Name "hydra.ext.kusto.kql.PipelineExpression" + +-- | A 'print' command that outputs the value of an expression, optionally naming a column +data PrintCommand = + PrintCommand { + printCommandColumn :: (Maybe ColumnName), + printCommandExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_PrintCommand = Model.Name "hydra.ext.kusto.kql.PrintCommand" + +_PrintCommand_column = Model.Name "column" + +_PrintCommand_expression = Model.Name "expression" + +-- | An expression to project as a column, with an optional alias, used by a 'project' command +data Projection = + Projection { + projectionExpression :: Expression, + projectionAlias :: (Maybe ColumnName)} + deriving (Eq, Ord, Read, Show) + +_Projection = Model.Name "hydra.ext.kusto.kql.Projection" + +_Projection_expression = Model.Name "expression" + +_Projection_alias = Model.Name "alias" + +-- | A dotted property access on an expression, e.g. 'x.property' +data PropertyExpression = + PropertyExpression { + propertyExpressionExpression :: Expression, + propertyExpressionProperty :: String} + deriving (Eq, Ord, Read, Show) + +_PropertyExpression = Model.Name "hydra.ext.kusto.kql.PropertyExpression" + +_PropertyExpression_expression = Model.Name "expression" + +_PropertyExpression_property = Model.Name "property" + +-- | A complete KQL query, consisting of a single tabular expression +newtype Query = + Query { + unQuery :: TabularExpression} + deriving (Eq, Ord, Read, Show) + +_Query = Model.Name "hydra.ext.kusto.kql.Query" + +-- | Search across all datasets and columns or, if provided, specific datasets and/or columns +data SearchCommand = + SearchCommand { + searchCommandDatasets :: [TableName], + searchCommandPattern :: Expression} + deriving (Eq, Ord, Read, Show) + +_SearchCommand = Model.Name "hydra.ext.kusto.kql.SearchCommand" + +_SearchCommand_datasets = Model.Name "datasets" + +_SearchCommand_pattern = Model.Name "pattern" + +-- | A single sort key with an optional sort order, used by 'order by'/'sort by' +data SortBy = + SortBy { + sortByColumn :: ColumnName, + sortByOrder :: (Maybe Order)} + deriving (Eq, Ord, Read, Show) + +_SortBy = Model.Name "hydra.ext.kusto.kql.SortBy" + +_SortBy_column = Model.Name "column" + +_SortBy_order = Model.Name "order" + +-- | A 'summarize' command that computes aggregate columns, optionally grouped by other columns +data SummarizeCommand = + SummarizeCommand { + summarizeCommandColumns :: [ColumnAssignment], + summarizeCommandBy :: [ColumnName]} + deriving (Eq, Ord, Read, Show) + +_SummarizeCommand = Model.Name "hydra.ext.kusto.kql.SummarizeCommand" + +_SummarizeCommand_columns = Model.Name "columns" + +_SummarizeCommand_by = Model.Name "by" + +-- | The name of a table or dataset +newtype TableName = + TableName { + unTableName :: String} + deriving (Eq, Ord, Read, Show) + +_TableName = Model.Name "hydra.ext.kusto.kql.TableName" + +-- | An expression which produces a table: a command, pipeline, let expression, or table reference +data TabularExpression = + TabularExpressionCommand Command | + TabularExpressionPipeline PipelineExpression | + TabularExpressionLet LetExpression | + TabularExpressionTable TableName + deriving (Eq, Ord, Read, Show) + +_TabularExpression = Model.Name "hydra.ext.kusto.kql.TabularExpression" + +_TabularExpression_command = Model.Name "command" + +_TabularExpression_pipeline = Model.Name "pipeline" + +_TabularExpression_let = Model.Name "let" + +_TabularExpression_table = Model.Name "table" + +-- | A 'top' command that returns the first N rows sorted by the given columns +data TopCommand = + TopCommand { + topCommandCount :: Int, + topCommandSort :: [SortBy]} + deriving (Eq, Ord, Read, Show) + +_TopCommand = Model.Name "hydra.ext.kusto.kql.TopCommand" + +_TopCommand_count = Model.Name "count" + +_TopCommand_sort = Model.Name "sort" + +-- | A unary operator expression applied to a single operand +data UnaryExpression = + UnaryExpression { + unaryExpressionOperator :: UnaryOperator, + unaryExpressionExpression :: Expression} + deriving (Eq, Ord, Read, Show) + +_UnaryExpression = Model.Name "hydra.ext.kusto.kql.UnaryExpression" + +_UnaryExpression_operator = Model.Name "operator" + +_UnaryExpression_expression = Model.Name "expression" + +-- | A unary operator used in KQL expressions +data UnaryOperator = + UnaryOperatorNot + deriving (Eq, Ord, Read, Show) + +_UnaryOperator = Model.Name "hydra.ext.kusto.kql.UnaryOperator" + +_UnaryOperator_not = Model.Name "not" + +-- | A 'union' command that combines rows from multiple tables +data UnionCommand = + UnionCommand { + unionCommandParameters :: [Parameter], + unionCommandKind :: (Maybe UnionKind), + unionCommandWithSource :: (Maybe ColumnName), + unionCommandIsFuzzy :: (Maybe Bool), + unionCommandTables :: [TableName]} + deriving (Eq, Ord, Read, Show) + +_UnionCommand = Model.Name "hydra.ext.kusto.kql.UnionCommand" + +_UnionCommand_parameters = Model.Name "parameters" + +_UnionCommand_kind = Model.Name "kind" + +_UnionCommand_withSource = Model.Name "withSource" + +_UnionCommand_isFuzzy = Model.Name "isFuzzy" + +_UnionCommand_tables = Model.Name "tables" + +-- | Whether a union preserves only common columns (inner) or all columns (outer) +data UnionKind = + UnionKindInner | + UnionKindOuter + deriving (Eq, Ord, Read, Show) + +_UnionKind = Model.Name "hydra.ext.kusto.kql.UnionKind" + +_UnionKind_inner = Model.Name "inner" + +_UnionKind_outer = Model.Name "outer" diff --git a/src/main/haskell/Hydra/Ext/Osv/Schema.hs b/src/main/haskell/Hydra/Ext/Osv/Schema.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Osv/Schema.hs @@ -0,0 +1,266 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | See https://ossf.github.io/osv-schema + +module Hydra.Ext.Osv.Schema where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A person or entity credited with discovering, fixing, or reporting a vulnerability +data Credited = + Credited { + creditedName :: String, + creditedContact :: (Maybe [Url])} + deriving (Eq, Ord, Read, Show) + +_Credited = Model.Name "hydra.ext.osv.schema.Credited" + +_Credited_name = Model.Name "name" + +_Credited_contact = Model.Name "contact" + +-- | One of a limited set of defined ecosystems, currently Go, npm, OSS-Fuzz, PyPI, RubyGems, crates.io, Packagist, Maven, NuGet, Linux, Debian, Hex, Android, GitHub Actions, or Pub +newtype Ecosystem = + Ecosystem { + unEcosystem :: String} + deriving (Eq, Ord, Read, Show) + +_Ecosystem = Model.Name "hydra.ext.osv.schema.Ecosystem" + +-- | A single OSV vulnerability entry +data Entry = + Entry { + -- | The default value is '1.0.0', matching version 1.0 of the OSV Schema + entrySchemaVersion :: (Maybe OsvVersion), + entryId :: Id, + entryModified :: Timestamp, + entryPublished :: (Maybe Timestamp), + entryWithdrawn :: (Maybe Timestamp), + entryAliases :: (Maybe [Id]), + entryRelated :: (Maybe [Id]), + entrySummary :: (Maybe String), + entryDetails :: (Maybe Markdown), + entrySeverity :: (Maybe [Severity]), + entryAffected :: (Maybe [PackageVersions]), + entryReferences :: (Maybe [Reference]), + entryCredits :: (Maybe [Credited])} + deriving (Eq, Ord, Read, Show) + +_Entry = Model.Name "hydra.ext.osv.schema.Entry" + +_Entry_schemaVersion = Model.Name "schemaVersion" + +_Entry_id = Model.Name "id" + +_Entry_modified = Model.Name "modified" + +_Entry_published = Model.Name "published" + +_Entry_withdrawn = Model.Name "withdrawn" + +_Entry_aliases = Model.Name "aliases" + +_Entry_related = Model.Name "related" + +_Entry_summary = Model.Name "summary" + +_Entry_details = Model.Name "details" + +_Entry_severity = Model.Name "severity" + +_Entry_affected = Model.Name "affected" + +_Entry_references = Model.Name "references" + +_Entry_credits = Model.Name "credits" + +-- | A version event marking a point in a range where a vulnerability's status changes +data Event = + EventIntroduced VersionOrZero | + EventFixed Version | + EventLastAffected Version | + EventLimit VersionOrStar + deriving (Eq, Ord, Read, Show) + +_Event = Model.Name "hydra.ext.osv.schema.Event" + +_Event_introduced = Model.Name "introduced" + +_Event_fixed = Model.Name "fixed" + +_Event_lastAffected = Model.Name "lastAffected" + +_Event_limit = Model.Name "limit" + +-- | A string of the format -, where DB names the database and ENTRYID is in the format used by the database. For example: OSV-2020-111, CVE-2021-3114, or GHSA-vp9c-fpxx-744v +newtype Id = + Id { + unId :: String} + deriving (Eq, Ord, Read, Show) + +_Id = Model.Name "hydra.ext.osv.schema.Id" + +-- | CommonMark markdown text +newtype Markdown = + Markdown { + unMarkdown :: String} + deriving (Eq, Ord, Read, Show) + +_Markdown = Model.Name "hydra.ext.osv.schema.Markdown" + +-- | A string which follows the SemVer 2.0.0 format, with no leading 'v' prefix +newtype OsvVersion = + OsvVersion { + unOsvVersion :: String} + deriving (Eq, Ord, Read, Show) + +_OsvVersion = Model.Name "hydra.ext.osv.schema.OsvVersion" + +-- | The identity of a software package within a given ecosystem +data Package = + Package { + packageEcosystem :: Ecosystem, + packageName :: String, + packagePurl :: (Maybe Url)} + deriving (Eq, Ord, Read, Show) + +_Package = Model.Name "hydra.ext.osv.schema.Package" + +_Package_ecosystem = Model.Name "ecosystem" + +_Package_name = Model.Name "name" + +_Package_purl = Model.Name "purl" + +-- | The package affected by a vulnerability, along with its affected version ranges and versions +data PackageVersions = + PackageVersions { + packageVersionsPackage :: Package, + packageVersionsRanges :: (Maybe [VersionRange]), + packageVersionsVersions :: (Maybe [Version])} + deriving (Eq, Ord, Read, Show) + +_PackageVersions = Model.Name "hydra.ext.osv.schema.PackageVersions" + +_PackageVersions_package = Model.Name "package" + +_PackageVersions_ranges = Model.Name "ranges" + +_PackageVersions_versions = Model.Name "versions" + +-- | A link to additional information about a vulnerability, together with its type +data Reference = + Reference { + referenceType :: ReferenceType, + referenceUrl :: Url} + deriving (Eq, Ord, Read, Show) + +_Reference = Model.Name "hydra.ext.osv.schema.Reference" + +_Reference_type = Model.Name "type" + +_Reference_url = Model.Name "url" + +-- | One of ADVISORY, ARTICLE, REPORT, FIX, GIT, PACKAGE, EVIDENCE, or WEB +newtype ReferenceType = + ReferenceType { + unReferenceType :: String} + deriving (Eq, Ord, Read, Show) + +_ReferenceType = Model.Name "hydra.ext.osv.schema.ReferenceType" + +-- | A severity score for a vulnerability, together with the scoring type used +data Severity = + Severity { + severityType :: SeverityType, + severityScore :: SeverityScore} + deriving (Eq, Ord, Read, Show) + +_Severity = Model.Name "hydra.ext.osv.schema.Severity" + +_Severity_type = Model.Name "type" + +_Severity_score = Model.Name "score" + +-- | The severity score value, formatted according to its severity type +newtype SeverityScore = + SeverityScore { + unSeverityScore :: String} + deriving (Eq, Ord, Read, Show) + +_SeverityScore = Model.Name "hydra.ext.osv.schema.SeverityScore" + +-- | The value CVSS_V3, or future supported types +newtype SeverityType = + SeverityType { + unSeverityType :: String} + deriving (Eq, Ord, Read, Show) + +_SeverityType = Model.Name "hydra.ext.osv.schema.SeverityType" + +-- | An RFC3339-formatted timestamp in UTC (ending in 'Z') +newtype Timestamp = + Timestamp { + unTimestamp :: String} + deriving (Eq, Ord, Read, Show) + +_Timestamp = Model.Name "hydra.ext.osv.schema.Timestamp" + +-- | A URL string +newtype Url = + Url { + unUrl :: String} + deriving (Eq, Ord, Read, Show) + +_Url = Model.Name "hydra.ext.osv.schema.Url" + +-- | A version number in an ecosystem-specific format +newtype Version = + Version { + unVersion :: String} + deriving (Eq, Ord, Read, Show) + +_Version = Model.Name "hydra.ext.osv.schema.Version" + +-- | An ecosystem-specific version number, or the string '*' representing infinity +newtype VersionOrStar = + VersionOrStar { + unVersionOrStar :: String} + deriving (Eq, Ord, Read, Show) + +_VersionOrStar = Model.Name "hydra.ext.osv.schema.VersionOrStar" + +-- | An ecosystem-specific version number, or the string '0' representing a version that sorts before any other version +newtype VersionOrZero = + VersionOrZero { + unVersionOrZero :: String} + deriving (Eq, Ord, Read, Show) + +_VersionOrZero = Model.Name "hydra.ext.osv.schema.VersionOrZero" + +-- | A range of affected versions, expressed as a type and an ordered list of events +data VersionRange = + VersionRange { + versionRangeType :: VersionType, + versionRangeRepo :: (Maybe Url), + versionRangeEvents :: [Event]} + deriving (Eq, Ord, Read, Show) + +_VersionRange = Model.Name "hydra.ext.osv.schema.VersionRange" + +_VersionRange_type = Model.Name "type" + +_VersionRange_repo = Model.Name "repo" + +_VersionRange_events = Model.Name "events" + +-- | One of the values 'SEMVER', 'ECOSYSTEM', or 'GIT +newtype VersionType = + VersionType { + unVersionType :: String} + deriving (Eq, Ord, Read, Show) + +_VersionType = Model.Name "hydra.ext.osv.schema.VersionType" diff --git a/src/main/haskell/Hydra/Ext/Parquet/Format.hs b/src/main/haskell/Hydra/Ext/Parquet/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Parquet/Format.hs @@ -0,0 +1,990 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for the Parquet format. Based on the Thrift-based specification at: +-- | https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift + +module Hydra.Ext.Parquet.Format where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.ByteString as B +import qualified Data.Int as I + +-- | AES GCM CTR mode encryption parameters +data AesGcmCtrV1 = + AesGcmCtrV1 { + -- | AAD prefix + aesGcmCtrV1AadPrefix :: (Maybe B.ByteString), + -- | Unique file identifier part of AAD suffix + aesGcmCtrV1AadFileUnique :: (Maybe B.ByteString), + -- | In files encrypted with AAD prefix without storing it, readers must supply the prefix + aesGcmCtrV1SupplyAadPrefix :: (Maybe Bool)} + deriving (Eq, Ord, Read, Show) + +_AesGcmCtrV1 = Model.Name "hydra.ext.parquet.format.AesGcmCtrV1" + +_AesGcmCtrV1_aadPrefix = Model.Name "aadPrefix" + +_AesGcmCtrV1_aadFileUnique = Model.Name "aadFileUnique" + +_AesGcmCtrV1_supplyAadPrefix = Model.Name "supplyAadPrefix" + +-- | AES GCM mode encryption parameters +data AesGcmV1 = + AesGcmV1 { + -- | AAD prefix + aesGcmV1AadPrefix :: (Maybe B.ByteString), + -- | Unique file identifier part of AAD suffix + aesGcmV1AadFileUnique :: (Maybe B.ByteString), + -- | In files encrypted with AAD prefix without storing it, readers must supply the prefix + aesGcmV1SupplyAadPrefix :: (Maybe Bool)} + deriving (Eq, Ord, Read, Show) + +_AesGcmV1 = Model.Name "hydra.ext.parquet.format.AesGcmV1" + +_AesGcmV1_aadPrefix = Model.Name "aadPrefix" + +_AesGcmV1_aadFileUnique = Model.Name "aadFileUnique" + +_AesGcmV1_supplyAadPrefix = Model.Name "supplyAadPrefix" + +-- | The algorithm used in Bloom filter. +data BloomFilterAlgorithm = + -- | Block-based Bloom filter. + BloomFilterAlgorithmBlock + deriving (Eq, Ord, Read, Show) + +_BloomFilterAlgorithm = Model.Name "hydra.ext.parquet.format.BloomFilterAlgorithm" + +_BloomFilterAlgorithm_block = Model.Name "block" + +-- | The compression used in the Bloom filter. +data BloomFilterCompression = + BloomFilterCompressionUncompressed + deriving (Eq, Ord, Read, Show) + +_BloomFilterCompression = Model.Name "hydra.ext.parquet.format.BloomFilterCompression" + +_BloomFilterCompression_uncompressed = Model.Name "uncompressed" + +-- | The hash function used in Bloom filter. This function takes the hash of a column value using plain encoding. +data BloomFilterHash = + -- | xxHash Strategy. + BloomFilterHashXxhash + deriving (Eq, Ord, Read, Show) + +_BloomFilterHash = Model.Name "hydra.ext.parquet.format.BloomFilterHash" + +_BloomFilterHash_xxhash = Model.Name "xxhash" + +-- | Bloom filter header is stored at beginning of Bloom filter data of each column and followed by its bitset. +data BloomFilterHeader = + BloomFilterHeader { + -- | The size of bitset in bytes + bloomFilterHeaderNumBytes :: Int, + -- | The algorithm for setting bits. + bloomFilterHeaderAlgorithm :: BloomFilterAlgorithm, + -- | The hash function used for Bloom filter. + bloomFilterHeaderHash :: BloomFilterHash, + -- | The compression used in the Bloom filter + bloomFilterHeaderCompression :: BloomFilterCompression} + deriving (Eq, Ord, Read, Show) + +_BloomFilterHeader = Model.Name "hydra.ext.parquet.format.BloomFilterHeader" + +_BloomFilterHeader_numBytes = Model.Name "numBytes" + +_BloomFilterHeader_algorithm = Model.Name "algorithm" + +_BloomFilterHeader_hash = Model.Name "hash" + +_BloomFilterHeader_compression = Model.Name "compression" + +-- | Enum to annotate whether lists of min/max elements inside ColumnIndex are ordered and if so, in which direction. +data BoundaryOrder = + BoundaryOrderUnordered | + BoundaryOrderAscending | + BoundaryOrderDescending + deriving (Eq, Ord, Read, Show) + +_BoundaryOrder = Model.Name "hydra.ext.parquet.format.BoundaryOrder" + +_BoundaryOrder_unordered = Model.Name "unordered" + +_BoundaryOrder_ascending = Model.Name "ascending" + +_BoundaryOrder_descending = Model.Name "descending" + +-- | Metadata and location of a single column's data within a row group +data ColumnChunk = + ColumnChunk { + -- | File where column data is stored. If not set, assumed to be same file as metadata. This path is relative to the current file. + columnChunkFilePath :: (Maybe String), + -- | Byte offset in file_path to the ColumnMetaData + columnChunkFileOffset :: I.Int64, + -- | Column metadata for this chunk. This is the same content as what is at file_path/file_offset. Having it here has it replicated in the file metadata. + columnChunkMetaData :: (Maybe ColumnMetaData), + -- | File offset of ColumnChunk's OffsetIndex + columnChunkOffsetIndexOffset :: (Maybe I.Int64), + -- | Size of ColumnChunk's OffsetIndex, in bytes + columnChunkOffsetIndexLength :: (Maybe Int), + -- | File offset of ColumnChunk's ColumnIndex + columnChunkColumnIndexOffset :: (Maybe I.Int64), + -- | Size of ColumnChunk's ColumnIndex, in bytes + columnChunkColumnIndexLength :: (Maybe Int), + -- | Crypto metadata of encrypted columns + columnChunkCryptoMetadata :: (Maybe ColumnCryptoMetaData), + -- | Encrypted column metadata for this chunk + columnChunkEncryptedColumnMetadata :: (Maybe B.ByteString)} + deriving (Eq, Ord, Read, Show) + +_ColumnChunk = Model.Name "hydra.ext.parquet.format.ColumnChunk" + +_ColumnChunk_filePath = Model.Name "filePath" + +_ColumnChunk_fileOffset = Model.Name "fileOffset" + +_ColumnChunk_metaData = Model.Name "metaData" + +_ColumnChunk_offsetIndexOffset = Model.Name "offsetIndexOffset" + +_ColumnChunk_offsetIndexLength = Model.Name "offsetIndexLength" + +_ColumnChunk_columnIndexOffset = Model.Name "columnIndexOffset" + +_ColumnChunk_columnIndexLength = Model.Name "columnIndexLength" + +_ColumnChunk_cryptoMetadata = Model.Name "cryptoMetadata" + +_ColumnChunk_encryptedColumnMetadata = Model.Name "encryptedColumnMetadata" + +-- | Crypto metadata for a column, specifying which key was used to encrypt it +data ColumnCryptoMetaData = + ColumnCryptoMetaDataEncryptionWithFooterKey EncryptionWithFooterKey | + ColumnCryptoMetaDataEncryptionWithColumnKey EncryptionWithColumnKey + deriving (Eq, Ord, Read, Show) + +_ColumnCryptoMetaData = Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData" + +_ColumnCryptoMetaData_encryptionWithFooterKey = Model.Name "encryptionWithFooterKey" + +_ColumnCryptoMetaData_encryptionWithColumnKey = Model.Name "encryptionWithColumnKey" + +-- | Description for ColumnIndex. Each [i] refers to the page at OffsetIndex.page_locations[i] +data ColumnIndex = + ColumnIndex { + -- | A list of Boolean values to determine the validity of the corresponding min and max values. If true, a page contains only null values, and writers have to set the corresponding entries in min_values and max_values to byte[0], so that all lists have the same length. If false, the corresponding entries in min_values and max_values must be valid. + columnIndexNullPages :: [Bool], + -- | minValues and maxValues are lists containing lower and upper bounds for the values of each page determined by the ColumnOrder of the column. These may be the actual minimum and maximum values found on a page, but can also be (more compact) values that do not exist on a page. For example, instead of storing "Blart Versenwald III", a writer may set min_values[i]="B", max_values[i]="C". Such more compact values must still be valid values within the column's logical type. Readers must make sure that list entries are populated before using them by inspecting null_pages. + columnIndexMinValues :: [B.ByteString], + columnIndexMaxValues :: [B.ByteString], + -- | Stores whether both min_values and max_values are orderd and if so, in which direction. This allows readers to perform binary searches in both lists. Readers cannot assume that max_values[i] <= min_values[i+1], even if the lists are ordered. + columnIndexBoundaryOrder :: BoundaryOrder, + -- | A list containing the number of null values for each page + columnIndexNullCounts :: (Maybe [I.Int64])} + deriving (Eq, Ord, Read, Show) + +_ColumnIndex = Model.Name "hydra.ext.parquet.format.ColumnIndex" + +_ColumnIndex_nullPages = Model.Name "nullPages" + +_ColumnIndex_minValues = Model.Name "minValues" + +_ColumnIndex_maxValues = Model.Name "maxValues" + +_ColumnIndex_boundaryOrder = Model.Name "boundaryOrder" + +_ColumnIndex_nullCounts = Model.Name "nullCounts" + +-- | Description for column metadata +data ColumnMetaData = + ColumnMetaData { + -- | Type of this column + columnMetaDataType :: Type, + -- | Set of all encodings used for this column. The purpose is to validate whether we can decode those pages. + columnMetaDataEncodings :: [Encoding], + -- | Path in schema + columnMetaDataPathInSchema :: [String], + -- | Compression codec + columnMetaDataCodec :: CompressionCodec, + -- | Number of values in this column + columnMetaDataNumValues :: I.Int64, + -- | total byte size of all uncompressed pages in this column chunk (including the headers) + columnMetaDataTotalUncompressedSize :: I.Int64, + -- | total byte size of all compressed, and potentially encrypted, pages in this column chunk (including the headers) + columnMetaDataTotalCompressedSize :: I.Int64, + -- | Optional key/value metadata + columnMetaDataKeyValueMetadata :: (Maybe [KeyValue]), + -- | Byte offset from beginning of file to first data page + columnMetaDataDataPageOffset :: I.Int64, + -- | Byte offset from beginning of file to root index page + columnMetaDataIndexPageOffset :: (Maybe I.Int64), + -- | Byte offset from the beginning of file to first (only) dictionary page + columnMetaDataDictionaryPageOffset :: (Maybe I.Int64), + -- | optional statistics for this column chunk + columnMetaDataStatistics :: (Maybe Statistics), + -- | Set of all encodings used for pages in this column chunk. This information can be used to determine if all data pages are dictionary encoded for example + columnMetaDataEncodingStats :: (Maybe [PageEncodingStats]), + -- | Byte offset from beginning of file to Bloom filter data. + columnMetaDataBloomFilterOffset :: (Maybe I.Int64)} + deriving (Eq, Ord, Read, Show) + +_ColumnMetaData = Model.Name "hydra.ext.parquet.format.ColumnMetaData" + +_ColumnMetaData_type = Model.Name "type" + +_ColumnMetaData_encodings = Model.Name "encodings" + +_ColumnMetaData_pathInSchema = Model.Name "pathInSchema" + +_ColumnMetaData_codec = Model.Name "codec" + +_ColumnMetaData_numValues = Model.Name "numValues" + +_ColumnMetaData_totalUncompressedSize = Model.Name "totalUncompressedSize" + +_ColumnMetaData_totalCompressedSize = Model.Name "totalCompressedSize" + +_ColumnMetaData_keyValueMetadata = Model.Name "keyValueMetadata" + +_ColumnMetaData_dataPageOffset = Model.Name "dataPageOffset" + +_ColumnMetaData_indexPageOffset = Model.Name "indexPageOffset" + +_ColumnMetaData_dictionaryPageOffset = Model.Name "dictionaryPageOffset" + +_ColumnMetaData_statistics = Model.Name "statistics" + +_ColumnMetaData_encodingStats = Model.Name "encodingStats" + +_ColumnMetaData_bloomFilterOffset = Model.Name "bloomFilterOffset" + +-- | Union to specify the order used for the min_value and max_value fields for a column. This union takes the role of an enhanced enum that allows rich elements (which will be needed for a collation-based ordering in the future). Possible values are: +-- | * TypeDefinedOrder - the column uses the order defined by its logical or physical type (if there is no logical type). +-- | If the reader does not support the value of this union, min and max stats for this column should be ignored. +data ColumnOrder = + -- | The sort orders for logical types are: + -- | UTF8 - unsigned byte-wise comparison + -- | INT8 - signed comparison + -- | INT16 - signed comparison + -- | INT32 - signed comparison + -- | INT64 - signed comparison + -- | UINT8 - unsigned comparison + -- | UINT16 - unsigned comparison + -- | UINT32 - unsigned comparison + -- | UINT64 - unsigned comparison + -- | DECIMAL - signed comparison of the represented value + -- | DATE - signed comparison + -- | TIME_MILLIS - signed comparison + -- | TIME_MICROS - signed comparison + -- | TIMESTAMP_MILLIS - signed comparison + -- | TIMESTAMP_MICROS - signed comparison + -- | INTERVAL - unsigned comparison + -- | JSON - unsigned byte-wise comparison + -- | BSON - unsigned byte-wise comparison + -- | ENUM - unsigned byte-wise comparison + -- | LIST - undefined + -- | MAP - undefined + -- | In the absence of logical types, the sort order is determined by the physical type: + -- | BOOLEAN - false, true + -- | INT32 - signed comparison + -- | INT64 - signed comparison + -- | INT96 (only used for legacy timestamps) - undefined + -- | FLOAT - signed comparison of the represented value (*) + -- | DOUBLE - signed comparison of the represented value (*) + -- | BYTE_ARRAY - unsigned byte-wise comparison + -- | FIXED_LEN_BYTE_ARRAY - unsigned byte-wise comparison + -- | (*) Because the sorting order is not specified properly for floating + -- | point values (relations vs. total ordering) the following + -- | compatibility rules should be applied when reading statistics: + -- | - If the min is a NaN, it should be ignored. + -- | - If the max is a NaN, it should be ignored. + -- | - If the min is +0, the row group may contain -0 values as well. + -- | - If the max is -0, the row group may contain +0 values as well. + -- | - When looking for NaN values, min and max should be ignored. + ColumnOrderTypeOrder + deriving (Eq, Ord, Read, Show) + +_ColumnOrder = Model.Name "hydra.ext.parquet.format.ColumnOrder" + +_ColumnOrder_typeOrder = Model.Name "typeOrder" + +-- | Supported compression algorithms. Codecs added in format version X.Y can be read by readers based on X.Y and later. Codec support may vary between readers based on the format version and libraries available at runtime. See Compression.md for a detailed specification of these algorithms. +data CompressionCodec = + CompressionCodecUncompressed | + CompressionCodecSnappy | + CompressionCodecGzip | + CompressionCodecLzo | + -- | Added in 2.4 + CompressionCodecBrotli | + -- | Added in 2.4 + CompressionCodecZstd | + -- | Added in 2.9 + CompressionCodecLz4Raw + deriving (Eq, Ord, Read, Show) + +_CompressionCodec = Model.Name "hydra.ext.parquet.format.CompressionCodec" + +_CompressionCodec_uncompressed = Model.Name "uncompressed" + +_CompressionCodec_snappy = Model.Name "snappy" + +_CompressionCodec_gzip = Model.Name "gzip" + +_CompressionCodec_lzo = Model.Name "lzo" + +_CompressionCodec_brotli = Model.Name "brotli" + +_CompressionCodec_zstd = Model.Name "zstd" + +_CompressionCodec_lz4Raw = Model.Name "lz4Raw" + +-- | Data page header +data DataPageHeader = + DataPageHeader { + -- | Number of values, including NULLs, in this data page. + dataPageHeaderNumValues :: Int, + -- | Encoding used for this data page + dataPageHeaderEncoding :: Encoding, + -- | Encoding used for definition levels + dataPageHeaderDefinitionLevelEncoding :: Encoding, + -- | Encoding used for repetition levels + dataPageHeaderRepetitionLevelEncoding :: Encoding, + -- | Optional statistics for the data in this page + dataPageHeaderStatistics :: (Maybe Statistics)} + deriving (Eq, Ord, Read, Show) + +_DataPageHeader = Model.Name "hydra.ext.parquet.format.DataPageHeader" + +_DataPageHeader_numValues = Model.Name "numValues" + +_DataPageHeader_encoding = Model.Name "encoding" + +_DataPageHeader_definitionLevelEncoding = Model.Name "definitionLevelEncoding" + +_DataPageHeader_repetitionLevelEncoding = Model.Name "repetitionLevelEncoding" + +_DataPageHeader_statistics = Model.Name "statistics" + +-- | New page format allowing reading levels without decompressing the data Repetition and definition levels are uncompressed The remaining section containing the data is compressed if is_compressed is true +data DataPageHeaderV2 = + DataPageHeaderV2 { + -- | Number of values, including NULLs, in this data page. + dataPageHeaderV2NumValues :: Int, + -- | Number of NULL values, in this data page. Number of non-null = num_values - num_nulls which is also the number of values in the data section + dataPageHeaderV2NumNulls :: Int, + -- | Number of rows in this data page. which means pages change on record boundaries (r = 0) + dataPageHeaderV2NumRows :: Int, + -- | Encoding used for data in this page + dataPageHeaderV2Encoding :: Encoding, + -- | length of the definition levels + dataPageHeaderV2DefinitionLevelsByteLength :: Int, + -- | length of the repetition levels + dataPageHeaderV2RepetitionLevelsByteLength :: Int, + -- | whether the values are compressed. Which means the section of the page between definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included) is compressed with the compression_codec. If missing it is considered compressed + dataPageHeaderV2IsCompressed :: (Maybe Bool), + -- | optional statistics for the data in this page + dataPageHeaderV2Statistics :: (Maybe Statistics)} + deriving (Eq, Ord, Read, Show) + +_DataPageHeaderV2 = Model.Name "hydra.ext.parquet.format.DataPageHeaderV2" + +_DataPageHeaderV2_numValues = Model.Name "numValues" + +_DataPageHeaderV2_numNulls = Model.Name "numNulls" + +_DataPageHeaderV2_numRows = Model.Name "numRows" + +_DataPageHeaderV2_encoding = Model.Name "encoding" + +_DataPageHeaderV2_definitionLevelsByteLength = Model.Name "definitionLevelsByteLength" + +_DataPageHeaderV2_repetitionLevelsByteLength = Model.Name "repetitionLevelsByteLength" + +_DataPageHeaderV2_isCompressed = Model.Name "isCompressed" + +_DataPageHeaderV2_statistics = Model.Name "statistics" + +-- | Decimal logical type annotation. To maintain forward-compatibility in v1, implementations using this logical type must also set scale and precision on the annotated SchemaElement. Allowed for physical types: INT32, INT64, FIXED, and BINARY +data DecimalType = + DecimalType { + decimalTypeScale :: Int, + decimalTypePrecision :: Int} + deriving (Eq, Ord, Read, Show) + +_DecimalType = Model.Name "hydra.ext.parquet.format.DecimalType" + +_DecimalType_scale = Model.Name "scale" + +_DecimalType_precision = Model.Name "precision" + +-- | The dictionary page must be placed at the first position of the column chunk if it is partly or completely dictionary encoded. At most one dictionary page can be placed in a column chunk. +data DictionaryPageHeader = + DictionaryPageHeader { + -- | Number of values in the dictionary + dictionaryPageHeaderNumValues :: Int, + -- | Encoding using this dictionary page + dictionaryPageHeaderEncoding :: Encoding, + -- | If true, the entries in the dictionary are sorted in ascending order + dictionaryPageHeaderIsSorted :: (Maybe Bool)} + deriving (Eq, Ord, Read, Show) + +_DictionaryPageHeader = Model.Name "hydra.ext.parquet.format.DictionaryPageHeader" + +_DictionaryPageHeader_numValues = Model.Name "numValues" + +_DictionaryPageHeader_encoding = Model.Name "encoding" + +_DictionaryPageHeader_isSorted = Model.Name "isSorted" + +-- | Encodings supported by Parquet. Not all encodings are valid for all types. These enums are also used to specify the encoding of definition and repetition levels. See the accompanying doc for the details of the more complicated encodings. +data Encoding = + -- | Default encoding. + -- | BOOLEAN - 1 bit per value. 0 is false; 1 is true. + -- | INT32 - 4 bytes per value. Stored as little-endian. + -- | INT64 - 8 bytes per value. Stored as little-endian. + -- | FLOAT - 4 bytes per value. IEEE. Stored as little-endian. + -- | DOUBLE - 8 bytes per value. IEEE. Stored as little-endian. + -- | BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes. + -- | FIXED_LEN_BYTE_ARRAY - Just the bytes. + EncodingPlain | + -- | Group packed run length encoding. Usable for definition/repetition levels encoding and Booleans (on one bit: 0 is false; 1 is true.) + EncodingRle | + -- | Bit packed encoding. This can only be used if the data has a known max width. Usable for definition/repetition levels encoding. + EncodingBitPacked | + -- | Delta encoding for integers. This can be used for int columns and works best on sorted data + EncodingDeltaBinaryPacked | + -- | Encoding for byte arrays to separate the length values and the data. The lengths are encoded using DELTA_BINARY_PACKED + EncodingDeltaLengthByteArray | + -- | Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED. Suffixes are stored as delta length byte arrays. + EncodingDeltaByteArray | + -- | Dictionary encoding: the ids are encoded using the RLE encoding + EncodingRleDictionary | + -- | Encoding for floating-point data. K byte-streams are created where K is the size in bytes of the data type. The individual bytes of an FP value are scattered to the corresponding stream and the streams are concatenated. This itself does not reduce the size of the data but can lead to better compression afterwards. + EncodingByteStreamSplit + deriving (Eq, Ord, Read, Show) + +_Encoding = Model.Name "hydra.ext.parquet.format.Encoding" + +_Encoding_plain = Model.Name "plain" + +_Encoding_rle = Model.Name "rle" + +_Encoding_bitPacked = Model.Name "bitPacked" + +_Encoding_deltaBinaryPacked = Model.Name "deltaBinaryPacked" + +_Encoding_deltaLengthByteArray = Model.Name "deltaLengthByteArray" + +_Encoding_deltaByteArray = Model.Name "deltaByteArray" + +_Encoding_rleDictionary = Model.Name "rleDictionary" + +_Encoding_byteStreamSplit = Model.Name "byteStreamSplit" + +-- | The encryption algorithm used to protect a Parquet file, with its parameters +data EncryptionAlgorithm = + EncryptionAlgorithmAesGcmV1 AesGcmV1 | + EncryptionAlgorithmAesGcmCtrV1 AesGcmCtrV1 + deriving (Eq, Ord, Read, Show) + +_EncryptionAlgorithm = Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm" + +_EncryptionAlgorithm_aesGcmV1 = Model.Name "aesGcmV1" + +_EncryptionAlgorithm_aesGcmCtrV1 = Model.Name "aesGcmCtrV1" + +-- | Identifies a column as encrypted with its own per-column encryption key +data EncryptionWithColumnKey = + EncryptionWithColumnKey { + -- | Column path in schema + encryptionWithColumnKeyPathInSchema :: [String], + -- | Retrieval metadata of column encryption key + encryptionWithColumnKeyKeyMetadata :: (Maybe B.ByteString)} + deriving (Eq, Ord, Read, Show) + +_EncryptionWithColumnKey = Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey" + +_EncryptionWithColumnKey_pathInSchema = Model.Name "pathInSchema" + +_EncryptionWithColumnKey_keyMetadata = Model.Name "keyMetadata" + +-- | Identifies a column as encrypted with the same key used to encrypt the footer +type EncryptionWithFooterKey = () + +_EncryptionWithFooterKey = Model.Name "hydra.ext.parquet.format.EncryptionWithFooterKey" + +-- | Representation of Schemas +data FieldRepetitionType = + -- | This field is required (can not be null) and each record has exactly 1 value. + FieldRepetitionTypeRequired | + -- | The field is optional (can be null) and each record has 0 or 1 values. + FieldRepetitionTypeOptional | + -- | The field is repeated and can contain 0 or more values + FieldRepetitionTypeRepeated + deriving (Eq, Ord, Read, Show) + +_FieldRepetitionType = Model.Name "hydra.ext.parquet.format.FieldRepetitionType" + +_FieldRepetitionType_required = Model.Name "required" + +_FieldRepetitionType_optional = Model.Name "optional" + +_FieldRepetitionType_repeated = Model.Name "repeated" + +-- | Crypto metadata for files with encrypted footer +data FileCryptoMetaData = + FileCryptoMetaData { + -- | Encryption algorithm. This field is only used for files with encrypted footer. Files with plaintext footer store algorithm id inside footer (FileMetaData structure). + fileCryptoMetaDataEncryptionAlgorithm :: EncryptionAlgorithm, + -- | Retrieval metadata of key used for encryption of footer, and (possibly) columns + fileCryptoMetaDataKeyMetadata :: (Maybe B.ByteString)} + deriving (Eq, Ord, Read, Show) + +_FileCryptoMetaData = Model.Name "hydra.ext.parquet.format.FileCryptoMetaData" + +_FileCryptoMetaData_encryptionAlgorithm = Model.Name "encryptionAlgorithm" + +_FileCryptoMetaData_keyMetadata = Model.Name "keyMetadata" + +-- | Description for file metadata +data FileMetaData = + FileMetaData { + -- | Version of this file + fileMetaDataVersion :: Int, + -- | Parquet schema for this file. This schema contains metadata for all the columns. The schema is represented as a tree with a single root. The nodes of the tree are flattened to a list by doing a depth-first traversal. The column metadata contains the path in the schema for that column which can be used to map columns to nodes in the schema. The first element is the root + fileMetaDataSchema :: [SchemaElement], + -- | Number of rows in this file + fileMetaDataNumRows :: I.Int64, + -- | Row groups in this file + fileMetaDataRowGroups :: [RowGroup], + -- | Optional key/value metadata + fileMetaDataKeyValueMetadata :: (Maybe [KeyValue]), + -- | String for application that wrote this file. This should be in the format version (build ). e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55) + fileMetaDataCreatedBy :: (Maybe String), + -- | Sort order used for the min_value and max_value fields in the Statistics objects and the min_values and max_values fields in the ColumnIndex objects of each column in this file. Sort orders are listed in the order matching the columns in the schema. The indexes are not necessary the same though, because only leaf nodes of the schema are represented in the list of sort orders. + -- | Without column_orders, the meaning of the min_value and max_value fields in the Statistics object and the ColumnIndex object is undefined. To ensure well-defined behaviour, if these fields are written to a Parquet file, column_orders must be written as well. + -- | The obsolete min and max fields in the Statistics object are always sorted by signed comparison regardless of column_orders. + fileMetaDataColumnOrders :: (Maybe [ColumnOrder]), + -- | Encryption algorithm. This field is set only in encrypted files with plaintext footer. Files with encrypted footer store algorithm id in FileCryptoMetaData structure. + fileMetaDataEncryptionAlgorithm :: (Maybe EncryptionAlgorithm), + -- | Retrieval metadata of key used for signing the footer. Used only in encrypted files with plaintext footer. + fileMetaDataFooterSigningKeyMetadata :: (Maybe B.ByteString)} + deriving (Eq, Ord, Read, Show) + +_FileMetaData = Model.Name "hydra.ext.parquet.format.FileMetaData" + +_FileMetaData_version = Model.Name "version" + +_FileMetaData_schema = Model.Name "schema" + +_FileMetaData_numRows = Model.Name "numRows" + +_FileMetaData_rowGroups = Model.Name "rowGroups" + +_FileMetaData_keyValueMetadata = Model.Name "keyValueMetadata" + +_FileMetaData_createdBy = Model.Name "createdBy" + +_FileMetaData_columnOrders = Model.Name "columnOrders" + +_FileMetaData_encryptionAlgorithm = Model.Name "encryptionAlgorithm" + +_FileMetaData_footerSigningKeyMetadata = Model.Name "footerSigningKeyMetadata" + +-- | Header for an index page (currently unused in the Parquet format) +type IndexPageHeader = () + +_IndexPageHeader = Model.Name "hydra.ext.parquet.format.IndexPageHeader" + +-- | Integer logical type annotation. bitWidth must be 8, 16, 32, or 64. Allowed for physical types: INT32, INT64 +data IntType = + IntType { + intTypeBitWidth :: I.Int16, + intTypeIsSigned :: Bool} + deriving (Eq, Ord, Read, Show) + +_IntType = Model.Name "hydra.ext.parquet.format.IntType" + +_IntType_bitWidth = Model.Name "bitWidth" + +_IntType_isSigned = Model.Name "isSigned" + +-- | Wrapper struct to store key values +data KeyValue = + KeyValue { + keyValueKey :: String, + keyValueValue :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_KeyValue = Model.Name "hydra.ext.parquet.format.KeyValue" + +_KeyValue_key = Model.Name "key" + +_KeyValue_value = Model.Name "value" + +-- | LogicalType annotations to replace ConvertedType. To maintain compatibility, implementations using LogicalType for a SchemaElement aust also set the corresponding ConvertedType (if any) from the following table. +data LogicalType = + -- | use ConvertedType UTF8 + LogicalTypeString | + -- | use ConvertedType MAP + LogicalTypeMap | + -- | use ConvertedType LIST + LogicalTypeList | + -- | use ConvertedType ENUM + LogicalTypeEnum | + -- | use ConvertedType DECIMAL + SchemaElement.{scale, precision} + LogicalTypeDecimal DecimalType | + -- | use ConvertedType DATE + LogicalTypeDate | + -- | use ConvertedType TIME_MICROS for TIME(isAdjustedToUTC = *, unit = MICROS). use ConvertedType TIME_MILLIS for TIME(isAdjustedToUTC = *, unit = MILLIS) + LogicalTypeTime TimeType | + -- | use ConvertedType TIMESTAMP_MICROS for TIMESTAMP(isAdjustedToUTC = *, unit = MICROS). use ConvertedType TIMESTAMP_MILLIS for TIMESTAMP(isAdjustedToUTC = *, unit = MILLIS) + LogicalTypeTimestamp TimestampType | + -- | use ConvertedType INT_* or UINT_* + LogicalTypeInteger IntType | + -- | no compatible ConvertedType + LogicalTypeUnknown | + -- | use ConvertedType JSON + LogicalTypeJson | + -- | use ConvertedType BSON + LogicalTypeBson | + -- | no compatible ConvertedType + LogicalTypeUuid + deriving (Eq, Ord, Read, Show) + +_LogicalType = Model.Name "hydra.ext.parquet.format.LogicalType" + +_LogicalType_string = Model.Name "string" + +_LogicalType_map = Model.Name "map" + +_LogicalType_list = Model.Name "list" + +_LogicalType_enum = Model.Name "enum" + +_LogicalType_decimal = Model.Name "decimal" + +_LogicalType_date = Model.Name "date" + +_LogicalType_time = Model.Name "time" + +_LogicalType_timestamp = Model.Name "timestamp" + +_LogicalType_integer = Model.Name "integer" + +_LogicalType_unknown = Model.Name "unknown" + +_LogicalType_json = Model.Name "json" + +_LogicalType_bson = Model.Name "bson" + +_LogicalType_uuid = Model.Name "uuid" + +-- | The offset index for a column chunk, giving byte offsets and row indices of its pages +data OffsetIndex = + OffsetIndex { + -- | PageLocations, ordered by increasing PageLocation.offset. It is required that page_locations[i].first_row_index < page_locations[i+1].first_row_index. + offsetIndexPageLocations :: [PageLocation]} + deriving (Eq, Ord, Read, Show) + +_OffsetIndex = Model.Name "hydra.ext.parquet.format.OffsetIndex" + +_OffsetIndex_pageLocations = Model.Name "pageLocations" + +-- | statistics of a given page type and encoding +data PageEncodingStats = + PageEncodingStats { + -- | the page type (data/dic/...) + pageEncodingStatsPageType :: PageType, + -- | encoding of the page + pageEncodingStatsEncoding :: Encoding, + -- | number of pages of this type with this encoding + pageEncodingStatsCount :: Int} + deriving (Eq, Ord, Read, Show) + +_PageEncodingStats = Model.Name "hydra.ext.parquet.format.PageEncodingStats" + +_PageEncodingStats_pageType = Model.Name "pageType" + +_PageEncodingStats_encoding = Model.Name "encoding" + +_PageEncodingStats_count = Model.Name "count" + +-- | Common header shared by all page types, wrapping a type-specific header +data PageHeader = + PageHeader { + -- | the type of the page: indicates which of the *_header fields is set + pageHeaderType :: PageType, + -- | Uncompressed page size in bytes (not including this header) + pageHeaderUncompressedPageSize :: Int, + -- | Compressed (and potentially encrypted) page size in bytes, not including this header + pageHeaderCompressedPageSize :: Int, + -- | The 32bit CRC for the page, to be be calculated as follows: + -- | - Using the standard CRC32 algorithm + -- | - On the data only, i.e. this header should not be included. 'Data' + -- | hereby refers to the concatenation of the repetition levels, the + -- | definition levels and the column value, in this exact order. + -- | - On the encoded versions of the repetition levels, definition levels and + -- | column values + -- | - On the compressed versions of the repetition levels, definition levels + -- | and column values where possible; + -- | - For v1 data pages, the repetition levels, definition levels and column + -- | values are always compressed together. If a compression scheme is + -- | specified, the CRC shall be calculated on the compressed version of + -- | this concatenation. If no compression scheme is specified, the CRC + -- | shall be calculated on the uncompressed version of this concatenation. + -- | - For v2 data pages, the repetition levels and definition levels are + -- | handled separately from the data and are never compressed (only + -- | encoded). If a compression scheme is specified, the CRC shall be + -- | calculated on the concatenation of the uncompressed repetition levels, + -- | uncompressed definition levels and the compressed column values. + -- | If no compression scheme is specified, the CRC shall be calculated on + -- | the uncompressed concatenation. + -- | - In encrypted columns, CRC is calculated after page encryption; the + -- | encryption itself is performed after page compression (if compressed) + -- | If enabled, this allows for disabling checksumming in HDFS if only a few pages need to be read. + pageHeaderCrc :: (Maybe Int), + pageHeaderDataPageHeader :: (Maybe DataPageHeader), + pageHeaderIndexPageHeader :: (Maybe IndexPageHeader), + pageHeaderDictionaryPageHeader :: (Maybe DictionaryPageHeader), + pageHeaderDataPageHeaderV2 :: (Maybe DataPageHeaderV2)} + deriving (Eq, Ord, Read, Show) + +_PageHeader = Model.Name "hydra.ext.parquet.format.PageHeader" + +_PageHeader_type = Model.Name "type" + +_PageHeader_uncompressedPageSize = Model.Name "uncompressedPageSize" + +_PageHeader_compressedPageSize = Model.Name "compressedPageSize" + +_PageHeader_crc = Model.Name "crc" + +_PageHeader_dataPageHeader = Model.Name "dataPageHeader" + +_PageHeader_indexPageHeader = Model.Name "indexPageHeader" + +_PageHeader_dictionaryPageHeader = Model.Name "dictionaryPageHeader" + +_PageHeader_dataPageHeaderV2 = Model.Name "dataPageHeaderV2" + +-- | Location and size of a single page, used as an entry in an OffsetIndex +data PageLocation = + PageLocation { + -- | Offset of the page in the file + pageLocationOffset :: I.Int64, + -- | Size of the page, including header. Sum of compressed_page_size and header length + pageLocationCompressedPageSize :: Int, + -- | Index within the RowGroup of the first row of the page; this means pages change on record boundaries (r = 0). + pageLocationFirstRowIndex :: I.Int64} + deriving (Eq, Ord, Read, Show) + +_PageLocation = Model.Name "hydra.ext.parquet.format.PageLocation" + +_PageLocation_offset = Model.Name "offset" + +_PageLocation_compressedPageSize = Model.Name "compressedPageSize" + +_PageLocation_firstRowIndex = Model.Name "firstRowIndex" + +-- | The type of a page within a column chunk +data PageType = + PageTypeDataPage | + PageTypeIndexPage | + PageTypeDictionaryPage | + PageTypeDataPageV2 + deriving (Eq, Ord, Read, Show) + +_PageType = Model.Name "hydra.ext.parquet.format.PageType" + +_PageType_dataPage = Model.Name "dataPage" + +_PageType_indexPage = Model.Name "indexPage" + +_PageType_dictionaryPage = Model.Name "dictionaryPage" + +_PageType_dataPageV2 = Model.Name "dataPageV2" + +-- | Metadata for a horizontal partition of the data into a row group +data RowGroup = + RowGroup { + -- | Metadata for each column chunk in this row group. This list must have the same order as the SchemaElement list in FileMetaData. + rowGroupColumns :: [ColumnChunk], + -- | Total byte size of all the uncompressed column data in this row group + rowGroupTotalByteSize :: I.Int64, + -- | Number of rows in this row group + rowGroupNumRows :: I.Int64, + -- | If set, specifies a sort ordering of the rows in this RowGroup. The sorting columns can be a subset of all the columns. + rowGroupSortingColumns :: (Maybe [SortingColumn]), + -- | Byte offset from beginning of file to first page (data or dictionary) in this row group + rowGroupFileOffset :: (Maybe I.Int64), + -- | Total byte size of all compressed (and potentially encrypted) column data in this row group + rowGroupTotalCompressedSize :: (Maybe I.Int64), + -- | Row group ordinal in the file + rowGroupOrdinal :: (Maybe I.Int16)} + deriving (Eq, Ord, Read, Show) + +_RowGroup = Model.Name "hydra.ext.parquet.format.RowGroup" + +_RowGroup_columns = Model.Name "columns" + +_RowGroup_totalByteSize = Model.Name "totalByteSize" + +_RowGroup_numRows = Model.Name "numRows" + +_RowGroup_sortingColumns = Model.Name "sortingColumns" + +_RowGroup_fileOffset = Model.Name "fileOffset" + +_RowGroup_totalCompressedSize = Model.Name "totalCompressedSize" + +_RowGroup_ordinal = Model.Name "ordinal" + +-- | Represents a element inside a schema definition. +-- | - if it is a group (inner node) then type is undefined and num_children is defined +-- | - if it is a primitive type (leaf) then type is defined and num_children is undefined +-- | the nodes are listed in depth first traversal order. +data SchemaElement = + SchemaElement { + -- | Data type for this field. Not set if the current element is a non-leaf node + schemaElementType :: (Maybe Type), + -- | If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values. Otherwise, if specified, this is the maximum bit length to store any of the values. (e.g. a low cardinality INT col could have this set to 3). Note that this is in the schema, and therefore fixed for the entire file. + schemaElementTypeLength :: (Maybe Int), + -- | repetition of the field. The root of the schema does not have a repetition_type. All other nodes must have one + schemaElementRepetitionType :: (Maybe FieldRepetitionType), + -- | Name of the field in the schema + schemaElementName :: String, + -- | Nested fields. Since thrift does not support nested fields, the nesting is flattened to a single list by a depth-first traversal. The children count is used to construct the nested relationship. This field is not set when the element is a primitive type + schemaElementNumChildren :: (Maybe Int), + -- | When the original schema supports field ids, this will save the original field id in the parquet schema + schemaElementFieldId :: (Maybe Int), + -- | The logical type of this SchemaElement. LogicalType replaces ConvertedType, but ConvertedType is still required for some logical types to ensure forward-compatibility in format v1. + schemaElementLogicalType :: (Maybe LogicalType)} + deriving (Eq, Ord, Read, Show) + +_SchemaElement = Model.Name "hydra.ext.parquet.format.SchemaElement" + +_SchemaElement_type = Model.Name "type" + +_SchemaElement_typeLength = Model.Name "typeLength" + +_SchemaElement_repetitionType = Model.Name "repetitionType" + +_SchemaElement_name = Model.Name "name" + +_SchemaElement_numChildren = Model.Name "numChildren" + +_SchemaElement_fieldId = Model.Name "fieldId" + +_SchemaElement_logicalType = Model.Name "logicalType" + +-- | Wrapper struct to specify sort order +data SortingColumn = + SortingColumn { + -- | The column index (in this row group) + sortingColumnColumnIdx :: Int, + -- | If true, indicates this column is sorted in descending order. + sortingColumnDescending :: Bool, + -- | If true, nulls will come before non-null values, otherwise, nulls go at the end. + sortingColumnNullsFirst :: Bool} + deriving (Eq, Ord, Read, Show) + +_SortingColumn = Model.Name "hydra.ext.parquet.format.SortingColumn" + +_SortingColumn_columnIdx = Model.Name "columnIdx" + +_SortingColumn_descending = Model.Name "descending" + +_SortingColumn_nullsFirst = Model.Name "nullsFirst" + +-- | Statistics per row group and per page. All fields are optional. +data Statistics = + Statistics { + statisticsNullCount :: (Maybe Integer), + statisticsDistinctCount :: (Maybe Integer), + -- | Max value for the column, determined by its ColumnOrder. Values are encoded using PLAIN encoding, except that variable-length byte arrays do not include a length prefix. + statisticsMaxValue :: (Maybe B.ByteString), + -- | Max value for the column, determined by its ColumnOrder. Values are encoded using PLAIN encoding, except that variable-length byte arrays do not include a length prefix. + statisticsMinValue :: (Maybe B.ByteString)} + deriving (Eq, Ord, Read, Show) + +_Statistics = Model.Name "hydra.ext.parquet.format.Statistics" + +_Statistics_nullCount = Model.Name "nullCount" + +_Statistics_distinctCount = Model.Name "distinctCount" + +_Statistics_maxValue = Model.Name "maxValue" + +_Statistics_minValue = Model.Name "minValue" + +-- | Time logical type annotation. Allowed for physical types: INT32 (millis), INT64 (micros, nanos) +data TimeType = + TimeType { + timeTypeIsAdjustedToUtc :: Bool, + timeTypeUnit :: TimeUnit} + deriving (Eq, Ord, Read, Show) + +_TimeType = Model.Name "hydra.ext.parquet.format.TimeType" + +_TimeType_isAdjustedToUtc = Model.Name "isAdjustedToUtc" + +_TimeType_unit = Model.Name "unit" + +-- | The unit of measurement for a TIME or TIMESTAMP logical type +data TimeUnit = + TimeUnitMillis | + TimeUnitMicros | + TimeUnitNanos + deriving (Eq, Ord, Read, Show) + +_TimeUnit = Model.Name "hydra.ext.parquet.format.TimeUnit" + +_TimeUnit_millis = Model.Name "millis" + +_TimeUnit_micros = Model.Name "micros" + +_TimeUnit_nanos = Model.Name "nanos" + +-- | Timestamp logical type annotation. Allowed for physical types: INT64 +data TimestampType = + TimestampType { + timestampTypeIsAdjustedToUtc :: Bool, + timestampTypeUnit :: TimeUnit} + deriving (Eq, Ord, Read, Show) + +_TimestampType = Model.Name "hydra.ext.parquet.format.TimestampType" + +_TimestampType_isAdjustedToUtc = Model.Name "isAdjustedToUtc" + +_TimestampType_unit = Model.Name "unit" + +-- | Types supported by Parquet. These types are intended to be used in combination with the encodings to control the on disk storage format. For example INT16 is not included as a type since a good encoding of INT32 would handle this. +data Type = + TypeBoolean | + TypeInt32 | + TypeInt64 | + TypeFloat | + TypeDouble | + TypeByteArray | + TypeFixedLenByteArray + deriving (Eq, Ord, Read, Show) + +_Type = Model.Name "hydra.ext.parquet.format.Type" + +_Type_boolean = Model.Name "boolean" + +_Type_int32 = Model.Name "int32" + +_Type_int64 = Model.Name "int64" + +_Type_float = Model.Name "float" + +_Type_double = Model.Name "double" + +_Type_byteArray = Model.Name "byteArray" + +_Type_fixedLenByteArray = Model.Name "fixedLenByteArray" diff --git a/src/main/haskell/Hydra/Ext/Pegasus/Coder.hs b/src/main/haskell/Hydra/Ext/Pegasus/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Pegasus/Coder.hs @@ -0,0 +1,307 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Pegasus PDL code generator: converts Hydra modules to PDL schema files + +module Hydra.Ext.Pegasus.Coder where + +import qualified Hydra.Core.Analysis as Analysis +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Dependencies as Dependencies +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Environment as Environment +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Print.Model as PrintModel +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.Sorting as Sorting +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Pegasus.Language as Language +import qualified Hydra.Ext.Pegasus.Pdl as Pdl +import qualified Hydra.Ext.Pegasus.Serde as Serde +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | Construct PDL schema files from type definitions, with topological sorting and cycle detection +constructModule :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Packaging.Module -> [Packaging.TypeDefinition] -> Either Errors.Error (M.Map String Pdl.SchemaFile) +constructModule cx g aliases mod typeDefs = + + let groups = Dependencies.topologicalSortTypeDefinitions typeDefs + in (Optionals.match (Lists.find (\grp -> Ordering.gt (Lists.length grp) 1) groups) ( + let sortedDefs = Lists.concat groups + in (Eithers.bind (Eithers.mapList (\typeDef -> typeToSchema cx g aliases mod typeDef) sortedDefs) (\schemas -> Right (Maps.fromList (Lists.map (toPair mod aliases) schemas))))) (\cycle -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "types form a cycle (unsupported in PDL): [" (Strings.concat2 (Strings.join ", " (Lists.map (\td -> Model.unName (Packaging.typeDefinitionName td)) cycle)) "]")))))) + +-- | Create PDL annotations from an optional doc string +doc :: Maybe String -> Pdl.Annotations +doc s = + Pdl.Annotations { + Pdl.annotationsDoc = s, + Pdl.annotationsDeprecated = False} + +-- | Encode a Hydra type as a PDL schema, failing if it resolves to a nested named schema +encode :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.Type -> Either Errors.Error Pdl.Schema +encode cx g aliases t = + case (Strip.deannotateType t) of + Model.TypeRecord v0 -> Logic.ifElse (Lists.isEmpty v0) (encode cx g aliases (Model.TypeLiteral (Model.LiteralTypeInteger Model.IntegerTypeInt32))) (Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintModel.type_ t))))) res)) + _ -> Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintModel.type_ t))))) res) + +-- | Encode a Hydra field type as a PDL enum field, converting the name to upper snake case +encodeEnumField :: t0 -> Graph.Graph -> Model.FieldType -> Either Errors.Error Pdl.EnumField +encodeEnumField cx g ft = + + let name = Model.fieldTypeName ft + typ = Model.fieldTypeType ft + in (Eithers.bind (getAnns cx g typ) (\anns -> Right (Pdl.EnumField { + Pdl.enumFieldName = (Pdl.EnumFieldName (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionUpperSnake (Model.unName name))), + Pdl.enumFieldAnnotations = anns}))) + +-- | Encode a type as a PDL schema together with a flag indicating whether it was optional +encodePossiblyOptionalType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.Type -> Either Errors.Error (Pdl.Schema, Bool) +encodePossiblyOptionalType cx g aliases typ = + case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> Eithers.bind (encode cx g aliases v0) (\t -> Right (t, True)) + Model.TypeRecord _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeUnion _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeLiteral _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeList _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeMap _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeSet _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeVariable _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeWrap _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeEither _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypePair _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeVoid -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) + Model.TypeAnnotated v0 -> encodePossiblyOptionalType cx g aliases (Model.annotatedTypeBody v0) + +-- | Encode a Hydra field type as a PDL record field +encodeRecordField :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.FieldType -> Either Errors.Error Pdl.RecordField +encodeRecordField cx g aliases ft = + + let name = Model.fieldTypeName ft + typ = Model.fieldTypeType ft + in (Eithers.bind (getAnns cx g typ) (\anns -> Eithers.bind (encodePossiblyOptionalType cx g aliases typ) (\optResult -> + let schema = Pairs.first optResult + optional = Pairs.second optResult + in (Right (Pdl.RecordField { + Pdl.recordFieldName = (Pdl.FieldName (Model.unName name)), + Pdl.recordFieldValue = schema, + Pdl.recordFieldOptional = optional, + Pdl.recordFieldDefault = Nothing, + Pdl.recordFieldAnnotations = anns}))))) + +-- | Encode a Hydra type as either a PDL Schema (Left) or a PDL NamedSchemaType (Right) +encodeType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.Type -> Either Errors.Error (Either Pdl.Schema Pdl.NamedSchemaType) +encodeType cx g aliases typ = + case typ of + Model.TypeAnnotated v0 -> encodeType cx g aliases (Model.annotatedTypeBody v0) + Model.TypeEither v0 -> Eithers.bind (encode cx g aliases (Model.eitherTypeLeft v0)) (\leftSchema -> Eithers.bind (encode cx g aliases (Model.eitherTypeRight v0)) (\rightSchema -> + let leftMember = + Pdl.UnionMember { + Pdl.unionMemberAlias = (Just (Pdl.FieldName "left")), + Pdl.unionMemberValue = leftSchema, + Pdl.unionMemberAnnotations = noAnnotations} + rightMember = + Pdl.UnionMember { + Pdl.unionMemberAlias = (Just (Pdl.FieldName "right")), + Pdl.unionMemberValue = rightSchema, + Pdl.unionMemberAnnotations = noAnnotations} + in (Right (Left (Pdl.SchemaUnion (Pdl.UnionSchema [ + leftMember, + rightMember])))))) + Model.TypeList v0 -> Eithers.bind (encode cx g aliases v0) (\inner -> Right (Left (Pdl.SchemaArray inner))) + Model.TypeLiteral v0 -> case v0 of + Model.LiteralTypeBinary -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeBytes)) + Model.LiteralTypeBoolean -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeBoolean)) + Model.LiteralTypeFloat v1 -> case v1 of + Model.FloatTypeFloat32 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeFloat)) + Model.FloatTypeFloat64 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeDouble)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "float32 or float64" (Strings.concat2 ", found: " (PrintModel.type_ typ)))))) + Model.LiteralTypeInteger v1 -> case v1 of + Model.IntegerTypeInt32 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeInt)) + Model.IntegerTypeInt64 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeLong)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "int32 or int64" (Strings.concat2 ", found: " (PrintModel.type_ typ)))))) + Model.LiteralTypeString -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeString)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "PDL-supported literal type" (Strings.concat2 ", found: " (PrintModel.type_ typ)))))) + Model.TypeMap v0 -> Eithers.bind (encode cx g aliases (Model.mapTypeValues v0)) (\inner -> Right (Left (Pdl.SchemaMap inner))) + Model.TypePair v0 -> Eithers.bind (encode cx g aliases (Model.pairTypeFirst v0)) (\firstSchema -> Eithers.bind (encode cx g aliases (Model.pairTypeSecond v0)) (\secondSchema -> + let firstField = + Pdl.RecordField { + Pdl.recordFieldName = (Pdl.FieldName "first"), + Pdl.recordFieldValue = firstSchema, + Pdl.recordFieldOptional = False, + Pdl.recordFieldDefault = Nothing, + Pdl.recordFieldAnnotations = noAnnotations} + secondField = + Pdl.RecordField { + Pdl.recordFieldName = (Pdl.FieldName "second"), + Pdl.recordFieldValue = secondSchema, + Pdl.recordFieldOptional = False, + Pdl.recordFieldDefault = Nothing, + Pdl.recordFieldAnnotations = noAnnotations} + in (Right (Right (Pdl.NamedSchemaTypeRecord (Pdl.RecordSchema { + Pdl.recordSchemaFields = [ + firstField, + secondField], + Pdl.recordSchemaIncludes = []})))))) + Model.TypeSet v0 -> Eithers.bind (encode cx g aliases v0) (\inner -> Right (Left (Pdl.SchemaArray inner))) + Model.TypeVariable v0 -> Right (Left (Pdl.SchemaNamed (pdlNameForElement aliases True v0))) + Model.TypeWrap v0 -> encodeType cx g aliases v0 + Model.TypeOptional _ -> Left (Errors.ErrorOther (Errors.OtherError "optionals unexpected at top level")) + Model.TypeRecord v0 -> Eithers.bind (Eithers.mapList (encodeRecordField cx g aliases) v0) (\rfields -> Right (Right (Pdl.NamedSchemaTypeRecord (Pdl.RecordSchema { + Pdl.recordSchemaFields = rfields, + Pdl.recordSchemaIncludes = []})))) + Model.TypeUnion v0 -> Logic.ifElse (Lists.foldl (\b -> \t -> Logic.and b (Equality.equal (Strip.deannotateType t) Model.TypeUnit)) True (Lists.map (\f -> Model.fieldTypeType f) v0)) (Eithers.bind (Eithers.mapList (encodeEnumField cx g) v0) (\fs -> Right (Right (Pdl.NamedSchemaTypeEnum (Pdl.EnumSchema { + Pdl.enumSchemaFields = fs}))))) (Eithers.bind (Eithers.mapList (encodeUnionField cx g aliases) v0) (\members -> Right (Left (Pdl.SchemaUnion (Pdl.UnionSchema members))))) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "PDL-supported type" (Strings.concat2 ", found: " (PrintModel.type_ typ)))))) + +-- | Encode a Hydra field type as a PDL union member, wrapping optional types in a null union +encodeUnionField :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Model.FieldType -> Either Errors.Error Pdl.UnionMember +encodeUnionField cx g aliases ft = + + let name = Model.fieldTypeName ft + typ = Model.fieldTypeType ft + in (Eithers.bind (getAnns cx g typ) (\anns -> Eithers.bind (encodePossiblyOptionalType cx g aliases typ) (\optResult -> + let s = Pairs.first optResult + optional = Pairs.second optResult + schema = + Logic.ifElse optional (Pdl.SchemaUnion (Pdl.UnionSchema (Lists.map (\ms -> simpleUnionMember ms) [ + Pdl.SchemaNull, + s]))) s + in (Right (Pdl.UnionMember { + Pdl.unionMemberAlias = (Just (Pdl.FieldName (Model.unName name))), + Pdl.unionMemberValue = schema, + Pdl.unionMemberAnnotations = anns}))))) + +-- | Get PDL annotations for a type by looking up its description in the graph +getAnns :: t0 -> Graph.Graph -> Model.Type -> Either Errors.Error Pdl.Annotations +getAnns cx g typ = Eithers.bind (Annotations.getTypeDescription cx g typ) (\r -> Right (doc r)) + +-- | Compute import aliases for a module's dependencies +importAliasesForModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (M.Map Packaging.ModuleName String) +importAliasesForModule cx g mod = + Eithers.bind (Analysis.moduleDependencyModuleNames cx g False True True False mod) (\nss -> Right (Maps.fromList (Lists.map (\ns_ -> (ns_, (slashesToDots (Packaging.unModuleName ns_)))) (Sets.toList nss)))) + +-- | Convert a Hydra module to a map of file paths to PDL schema strings +moduleToPdl :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String) +moduleToPdl mod defs cx g = + Eithers.bind (moduleToPegasusSchemas cx g mod defs) (\files -> Right (Maps.fromList (Lists.map (\pair -> (Pairs.first pair, (Serialization.printExpr (Serialization.parenthesize (Serde.schemaFileToExpr (Pairs.second pair)))))) (Maps.toList files)))) + +-- | Convert a Hydra module and its definitions to PDL schema files +moduleToPegasusSchemas :: t0 -> Graph.Graph -> Packaging.Module -> [Packaging.Definition] -> Either Errors.Error (M.Map String Pdl.SchemaFile) +moduleToPegasusSchemas cx g mod defs = + + let partitioned = Environment.partitionDefinitions defs + typeDefs = Pairs.first partitioned + in (Eithers.bind (importAliasesForModule cx g mod) (\aliases -> constructModule cx g aliases mod typeDefs)) + +-- | Empty PDL annotations +noAnnotations :: Pdl.Annotations +noAnnotations = + Pdl.Annotations { + Pdl.annotationsDoc = Nothing, + Pdl.annotationsDeprecated = False} + +-- | Convert a Hydra element name to a PDL qualified name +pdlNameForElement :: M.Map Packaging.ModuleName String -> Bool -> Model.Name -> Pdl.QualifiedName +pdlNameForElement aliases withNs name = + + let qn = Names.qualifyName name + ns_ = Util.qualifiedNameModuleName qn + local = Util.qualifiedNameLocal qn + alias = Optionals.bind ns_ (\n -> Maps.lookup n aliases) + in Pdl.QualifiedName { + Pdl.qualifiedNameName = (Pdl.Name local), + Pdl.qualifiedNameNamespace = (Logic.ifElse withNs (Optionals.map (\a -> Pdl.Namespace a) alias) Nothing)} + +-- | Convert a module's namespace to a PDL namespace +pdlNameForModule :: Packaging.Module -> Pdl.Namespace +pdlNameForModule mod = Pdl.Namespace (slashesToDots (Packaging.unModuleName (Packaging.moduleName mod))) + +-- | Create a simple union member without an alias +simpleUnionMember :: Pdl.Schema -> Pdl.UnionMember +simpleUnionMember schema = + Pdl.UnionMember { + Pdl.unionMemberAlias = Nothing, + Pdl.unionMemberValue = schema, + Pdl.unionMemberAnnotations = noAnnotations} + +-- | Replace all forward slashes with dots in a string +slashesToDots :: String -> String +slashesToDots s = Strings.join "." (Strings.splitOn "/" s) + +-- | Pair a file path derived from a module and schema name with the resulting PDL schema file +toPair :: Packaging.Module -> t0 -> (Pdl.NamedSchema, [Pdl.QualifiedName]) -> (String, Pdl.SchemaFile) +toPair mod aliases schemaPair = + + let schema = Pairs.first schemaPair + imports = Pairs.second schemaPair + ns_ = pdlNameForModule mod + local = Pdl.unName (Pdl.qualifiedNameName (Pdl.namedSchemaQualifiedName schema)) + path = + Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "pdl") (Packaging.ModuleName (Strings.concat2 (Packaging.unModuleName (Packaging.moduleName mod)) (Strings.concat2 "/" local))) + in ( + path, + Pdl.SchemaFile { + Pdl.schemaFileNamespace = ns_, + Pdl.schemaFilePackage = Nothing, + Pdl.schemaFileImports = imports, + Pdl.schemaFileSchemas = [ + schema]}) + +-- | Convert a Hydra type definition into a named PDL schema together with its imports +typeToSchema :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> t1 -> Packaging.TypeDefinition -> Either Errors.Error (Pdl.NamedSchema, [t2]) +typeToSchema cx g aliases mod typeDef = + + let typ = Model.typeSchemeBody (Packaging.typeDefinitionBody typeDef) + in (Eithers.bind (encodeType cx g aliases typ) (\res -> + let ptype = Eithers.either (\schema -> Pdl.NamedSchemaTypeTyperef schema) (\t -> t) res + in (Eithers.bind (Annotations.getTypeDescription cx g typ) (\descr -> + let anns = doc descr + qname = pdlNameForElement aliases False (Packaging.typeDefinitionName typeDef) + in (Right ( + Pdl.NamedSchema { + Pdl.namedSchemaQualifiedName = qname, + Pdl.namedSchemaType = ptype, + Pdl.namedSchemaAnnotations = anns}, + [])))))) diff --git a/src/main/haskell/Hydra/Ext/Pegasus/Language.hs b/src/main/haskell/Hydra/Ext/Pegasus/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Pegasus/Language.hs @@ -0,0 +1,114 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints for LinkedIn Pegasus (PDL) + +module Hydra.Ext.Pegasus.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Language constraints for LinkedIn Pegasus (PDL) +pdlLanguage :: Coders.Language +pdlLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.ext.pegasus.pdl"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "pdl")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBinary, + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = + Sets.fromList [ + Model.FloatTypeFloat32, + Model.FloatTypeFloat64] + integerTypes = + Sets.fromList [ + Model.IntegerTypeInt32, + Model.IntegerTypeInt64] + termVariants = + Sets.fromList [ + Variants.TermVariantEither, + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantMap, + Variants.TermVariantPair, + Variants.TermVariantSet, + Variants.TermVariantWrap, + Variants.TermVariantOptional, + Variants.TermVariantRecord, + Variants.TermVariantInject] + typeVariants = + Sets.fromList [ + Variants.TypeVariantAnnotated, + Variants.TypeVariantEither, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantPair, + Variants.TypeVariantSet, + Variants.TypeVariantWrap, + Variants.TypeVariantOptional, + Variants.TypeVariantRecord, + Variants.TypeVariantUnion, + Variants.TypeVariantVariable] + typePredicate = \_ -> True diff --git a/src/main/haskell/Hydra/Ext/Pegasus/Pdl.hs b/src/main/haskell/Hydra/Ext/Pegasus/Pdl.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Pegasus/Pdl.hs @@ -0,0 +1,288 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for PDL (Pegasus Data Language) schemas. Based on the specification at: +-- | https://linkedin.github.io/rest.li/pdl_schema + +module Hydra.Ext.Pegasus.Pdl where + +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Annotations which can be applied to record fields, aliased union members, enum symbols, or named schemas +data Annotations = + Annotations { + annotationsDoc :: (Maybe String), + annotationsDeprecated :: Bool} + deriving (Eq, Ord, Read, Show) + +_Annotations = Model.Name "hydra.ext.pegasus.pdl.Annotations" + +_Annotations_doc = Model.Name "doc" + +_Annotations_deprecated = Model.Name "deprecated" + +-- | A single symbol of a PDL enum schema, with its optional annotations +data EnumField = + EnumField { + enumFieldName :: EnumFieldName, + enumFieldAnnotations :: Annotations} + deriving (Eq, Ord, Read, Show) + +_EnumField = Model.Name "hydra.ext.pegasus.pdl.EnumField" + +_EnumField_name = Model.Name "name" + +_EnumField_annotations = Model.Name "annotations" + +-- | The name of a PDL enum symbol, conventionally in upper snake case +newtype EnumFieldName = + EnumFieldName { + unEnumFieldName :: String} + deriving (Eq, Ord, Read, Show) + +_EnumFieldName = Model.Name "hydra.ext.pegasus.pdl.EnumFieldName" + +-- | A PDL enum schema, defined as a fixed set of enumerated symbols +data EnumSchema = + EnumSchema { + enumSchemaFields :: [EnumField]} + deriving (Eq, Ord, Read, Show) + +_EnumSchema = Model.Name "hydra.ext.pegasus.pdl.EnumSchema" + +_EnumSchema_fields = Model.Name "fields" + +-- | The name of a record field or an aliased union member +newtype FieldName = + FieldName { + unFieldName :: String} + deriving (Eq, Ord, Read, Show) + +_FieldName = Model.Name "hydra.ext.pegasus.pdl.FieldName" + +-- | The unqualified (non-namespaced) name of a PDL named schema +newtype Name = + Name { + unName :: String} + deriving (Eq, Ord, Read, Show) + +_Name = Model.Name "hydra.ext.pegasus.pdl.Name" + +-- | A PDL schema that has a qualified name: a record, enum, or typeref +data NamedSchema = + NamedSchema { + namedSchemaQualifiedName :: QualifiedName, + namedSchemaType :: NamedSchemaType, + namedSchemaAnnotations :: Annotations} + deriving (Eq, Ord, Read, Show) + +_NamedSchema = Model.Name "hydra.ext.pegasus.pdl.NamedSchema" + +_NamedSchema_qualifiedName = Model.Name "qualifiedName" + +_NamedSchema_type = Model.Name "type" + +_NamedSchema_annotations = Model.Name "annotations" + +-- | The variety of a PDL named schema: record, enum, or typeref +data NamedSchemaType = + NamedSchemaTypeRecord RecordSchema | + NamedSchemaTypeEnum EnumSchema | + NamedSchemaTypeTyperef Schema + deriving (Eq, Ord, Read, Show) + +_NamedSchemaType = Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType" + +_NamedSchemaType_record = Model.Name "record" + +_NamedSchemaType_enum = Model.Name "enum" + +_NamedSchemaType_typeref = Model.Name "typeref" + +-- | A dot-separated PDL namespace, analogous to a Java package name +newtype Namespace = + Namespace { + unNamespace :: String} + deriving (Eq, Ord, Read, Show) + +_Namespace = Model.Name "hydra.ext.pegasus.pdl.Namespace" + +-- | The Java package under which generated bindings for a schema file are placed +newtype Package = + Package { + unPackage :: String} + deriving (Eq, Ord, Read, Show) + +_Package = Model.Name "hydra.ext.pegasus.pdl.Package" + +-- | One of the built-in PDL primitive types +data PrimitiveType = + PrimitiveTypeBoolean | + PrimitiveTypeBytes | + PrimitiveTypeDouble | + PrimitiveTypeFloat | + PrimitiveTypeInt | + PrimitiveTypeLong | + PrimitiveTypeString + deriving (Eq, Ord, Read, Show) + +_PrimitiveType = Model.Name "hydra.ext.pegasus.pdl.PrimitiveType" + +_PrimitiveType_boolean = Model.Name "boolean" + +_PrimitiveType_bytes = Model.Name "bytes" + +_PrimitiveType_double = Model.Name "double" + +_PrimitiveType_float = Model.Name "float" + +_PrimitiveType_int = Model.Name "int" + +_PrimitiveType_long = Model.Name "long" + +_PrimitiveType_string = Model.Name "string" + +-- | A custom key/value property attached to a PDL schema, field, or member +data Property = + Property { + propertyKey :: PropertyKey, + propertyValue :: (Maybe JsonModel.Value)} + deriving (Eq, Ord, Read, Show) + +_Property = Model.Name "hydra.ext.pegasus.pdl.Property" + +_Property_key = Model.Name "key" + +_Property_value = Model.Name "value" + +-- | The key of a custom PDL schema property, e.g. a dot-separated path +newtype PropertyKey = + PropertyKey { + unPropertyKey :: String} + deriving (Eq, Ord, Read, Show) + +_PropertyKey = Model.Name "hydra.ext.pegasus.pdl.PropertyKey" + +-- | A PDL name together with the optional namespace that qualifies it +data QualifiedName = + QualifiedName { + qualifiedNameName :: Name, + qualifiedNameNamespace :: (Maybe Namespace)} + deriving (Eq, Ord, Read, Show) + +_QualifiedName = Model.Name "hydra.ext.pegasus.pdl.QualifiedName" + +_QualifiedName_name = Model.Name "name" + +_QualifiedName_namespace = Model.Name "namespace" + +-- | Note: the default value for an enum-valued must be one of the enumerated string symbols +data RecordField = + RecordField { + recordFieldName :: FieldName, + recordFieldValue :: Schema, + recordFieldOptional :: Bool, + recordFieldDefault :: (Maybe JsonModel.Value), + recordFieldAnnotations :: Annotations} + deriving (Eq, Ord, Read, Show) + +_RecordField = Model.Name "hydra.ext.pegasus.pdl.RecordField" + +_RecordField_name = Model.Name "name" + +_RecordField_value = Model.Name "value" + +_RecordField_optional = Model.Name "optional" + +_RecordField_default = Model.Name "default" + +_RecordField_annotations = Model.Name "annotations" + +-- | Note: all included schemas must be record schemas +data RecordSchema = + RecordSchema { + recordSchemaFields :: [RecordField], + recordSchemaIncludes :: [NamedSchema]} + deriving (Eq, Ord, Read, Show) + +_RecordSchema = Model.Name "hydra.ext.pegasus.pdl.RecordSchema" + +_RecordSchema_fields = Model.Name "fields" + +_RecordSchema_includes = Model.Name "includes" + +-- | A PDL data schema: either a primitive, a reference by name, or a complex type +data Schema = + SchemaArray Schema | + SchemaFixed Int | + SchemaInline NamedSchema | + SchemaMap Schema | + SchemaNamed QualifiedName | + SchemaNull | + SchemaPrimitive PrimitiveType | + SchemaUnion UnionSchema + deriving (Eq, Ord, Read, Show) + +_Schema = Model.Name "hydra.ext.pegasus.pdl.Schema" + +_Schema_array = Model.Name "array" + +_Schema_fixed = Model.Name "fixed" + +_Schema_inline = Model.Name "inline" + +_Schema_map = Model.Name "map" + +_Schema_named = Model.Name "named" + +_Schema_null = Model.Name "null" + +_Schema_primitive = Model.Name "primitive" + +_Schema_union = Model.Name "union" + +-- | A .pdl source file: a namespace declaration, imports, and one or more named schemas +data SchemaFile = + SchemaFile { + schemaFileNamespace :: Namespace, + schemaFilePackage :: (Maybe Package), + schemaFileImports :: [QualifiedName], + schemaFileSchemas :: [NamedSchema]} + deriving (Eq, Ord, Read, Show) + +_SchemaFile = Model.Name "hydra.ext.pegasus.pdl.SchemaFile" + +_SchemaFile_namespace = Model.Name "namespace" + +_SchemaFile_package = Model.Name "package" + +_SchemaFile_imports = Model.Name "imports" + +_SchemaFile_schemas = Model.Name "schemas" + +-- | Note: annotations are only available for aliased members +data UnionMember = + UnionMember { + unionMemberAlias :: (Maybe FieldName), + unionMemberValue :: Schema, + unionMemberAnnotations :: Annotations} + deriving (Eq, Ord, Read, Show) + +_UnionMember = Model.Name "hydra.ext.pegasus.pdl.UnionMember" + +_UnionMember_alias = Model.Name "alias" + +_UnionMember_value = Model.Name "value" + +_UnionMember_annotations = Model.Name "annotations" + +-- | Note: unions are not allowed as member types of other unions +newtype UnionSchema = + UnionSchema { + unUnionSchema :: [UnionMember]} + deriving (Eq, Ord, Read, Show) + +_UnionSchema = Model.Name "hydra.ext.pegasus.pdl.UnionSchema" diff --git a/src/main/haskell/Hydra/Ext/Pegasus/Serde.hs b/src/main/haskell/Hydra/Ext/Pegasus/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Pegasus/Serde.hs @@ -0,0 +1,196 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Serialization functions for converting Pegasus PDL AST to abstract expressions + +module Hydra.Ext.Pegasus.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Pegasus.Pdl as Pdl +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Convert PDL annotations to an optional expression (doc comment) +annotationsToExpr :: Pdl.Annotations -> Maybe Ast.Expr +annotationsToExpr anns = + + let d = Pdl.annotationsDoc anns + in (Optionals.map (\s -> Serialization.cst (Formatting.javaStyleComment s)) d) + +-- | Convert a PDL enum field to an expression +enumFieldToExpr :: Pdl.EnumField -> Ast.Expr +enumFieldToExpr ef = + + let name = Pdl.unEnumFieldName (Pdl.enumFieldName ef) + anns = Pdl.enumFieldAnnotations ef + in (withAnnotations anns (Serialization.cst name)) + +-- | Convert a qualified name to an import expression +importToExpr :: Pdl.QualifiedName -> Ast.Expr +importToExpr qn = + Serialization.spaceSep [ + Serialization.cst "import", + (qualifiedNameToExpr qn)] + +-- | Convert a named schema to an expression +namedSchemaToExpr :: Pdl.NamedSchema -> Ast.Expr +namedSchemaToExpr ns = + + let qn = Pdl.namedSchemaQualifiedName ns + t = Pdl.namedSchemaType ns + anns = Pdl.namedSchemaAnnotations ns + in (withAnnotations anns (case t of + Pdl.NamedSchemaTypeRecord v0 -> + let fields = Pdl.recordSchemaFields v0 + in (Serialization.spaceSep [ + Serialization.cst "record", + (qualifiedNameToExpr qn), + (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle (Lists.map recordFieldToExpr fields))]) + Pdl.NamedSchemaTypeEnum v0 -> + let fields = Pdl.enumSchemaFields v0 + in (Serialization.spaceSep [ + Serialization.cst "enum", + (qualifiedNameToExpr qn), + (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle (Lists.map enumFieldToExpr fields))]) + Pdl.NamedSchemaTypeTyperef v0 -> Serialization.spaceSep [ + Serialization.cst "typeref", + (qualifiedNameToExpr qn), + (Serialization.cst "="), + (schemaToExpr v0)])) + +-- | Convert a primitive type to an expression +primitiveTypeToExpr :: Pdl.PrimitiveType -> Ast.Expr +primitiveTypeToExpr pt = + Serialization.cst (case pt of + Pdl.PrimitiveTypeBoolean -> "boolean" + Pdl.PrimitiveTypeBytes -> "bytes" + Pdl.PrimitiveTypeDouble -> "double" + Pdl.PrimitiveTypeFloat -> "float" + Pdl.PrimitiveTypeInt -> "int" + Pdl.PrimitiveTypeLong -> "long" + Pdl.PrimitiveTypeString -> "string") + +-- | Convert a qualified name to an expression +qualifiedNameToExpr :: Pdl.QualifiedName -> Ast.Expr +qualifiedNameToExpr qn = + + let name = Pdl.unName (Pdl.qualifiedNameName qn) + ns = Pdl.qualifiedNameNamespace qn + parts = + Optionals.givens [ + Optionals.map (\n -> Pdl.unNamespace n) ns, + (Optionals.given name)] + in (Serialization.cst (Strings.join "." parts)) + +-- | Convert a record field to an expression +recordFieldToExpr :: Pdl.RecordField -> Ast.Expr +recordFieldToExpr rf = + + let name = Pdl.unFieldName (Pdl.recordFieldName rf) + schema = Pdl.recordFieldValue rf + optional = Pdl.recordFieldOptional rf + anns = Pdl.recordFieldAnnotations rf + in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ + Optionals.given (Serialization.cst (Strings.concat2 name ":")), + (Logic.ifElse optional (Optionals.given (Serialization.cst "optional")) Nothing), + (Optionals.given (schemaToExpr schema))]))) + +-- | Convert a schema file to an expression +schemaFileToExpr :: Pdl.SchemaFile -> Ast.Expr +schemaFileToExpr sf = + + let ns = Pdl.unNamespace (Pdl.schemaFileNamespace sf) + pkg = Pdl.schemaFilePackage sf + imports = Pdl.schemaFileImports sf + schemas = Pdl.schemaFileSchemas sf + namespaceSec = + Optionals.given (Serialization.spaceSep [ + Serialization.cst "namespace", + (Serialization.cst ns)]) + packageSec = + Optionals.map (\p -> Serialization.spaceSep [ + Serialization.cst "package", + (Serialization.cst (Pdl.unPackage p))]) pkg + importsSec = + Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) + schemaSecs = Lists.map (\s -> Optionals.given (namedSchemaToExpr s)) schemas + in (Serialization.doubleNewlineSep (Optionals.givens (Lists.concat [ + [ + namespaceSec, + packageSec, + importsSec], + schemaSecs]))) + +-- | Convert a schema to an expression +schemaToExpr :: Pdl.Schema -> Ast.Expr +schemaToExpr schema = + case schema of + Pdl.SchemaArray v0 -> Serialization.noSep [ + Serialization.cst "array", + (Serialization.bracketList Serialization.inlineStyle [ + schemaToExpr v0])] + Pdl.SchemaMap v0 -> Serialization.noSep [ + Serialization.cst "map", + (Serialization.bracketList Serialization.inlineStyle [ + Serialization.cst "string", + (schemaToExpr v0)])] + Pdl.SchemaNamed v0 -> qualifiedNameToExpr v0 + Pdl.SchemaNull -> Serialization.cst "null" + Pdl.SchemaPrimitive v0 -> primitiveTypeToExpr v0 + Pdl.SchemaUnion v0 -> Serialization.noSep [ + Serialization.cst "union", + (Serialization.bracketList Serialization.fullBlockStyle (Lists.map unionMemberToExpr (Pdl.unUnionSchema v0)))] + +-- | Convert a union member to an expression +unionMemberToExpr :: Pdl.UnionMember -> Ast.Expr +unionMemberToExpr um = + + let alias = Pdl.unionMemberAlias um + schema = Pdl.unionMemberValue um + anns = Pdl.unionMemberAnnotations um + in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ + Optionals.map (\fn -> Serialization.cst (Strings.concat2 (Pdl.unFieldName fn) ":")) alias, + (Optionals.given (schemaToExpr schema))]))) + +-- | Prepend annotations (doc comment) to an expression +withAnnotations :: Pdl.Annotations -> Ast.Expr -> Ast.Expr +withAnnotations anns expr = + Serialization.newlineSep (Optionals.givens [ + annotationsToExpr anns, + (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Any.hs b/src/main/haskell/Hydra/Ext/Protobuf/Any.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Any.hs @@ -0,0 +1,26 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/any.proto + +module Hydra.Ext.Protobuf.Any where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.ByteString as B + +-- | `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. +data Any = + Any { + -- | A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. + anyTypeUrl :: String, + -- | Must be a valid serialized protocol buffer of the above specified type. + anyValue :: B.ByteString} + deriving (Eq, Ord, Read, Show) + +_Any = Model.Name "hydra.ext.protobuf.any.Any" + +_Any_typeUrl = Model.Name "typeUrl" + +_Any_value = Model.Name "value" diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Coder.hs b/src/main/haskell/Hydra/Ext/Protobuf/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Coder.hs @@ -0,0 +1,598 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Protobuf code generator: converts Hydra modules to Protocol Buffers v3 definitions + +module Hydra.Ext.Protobuf.Coder where + +import qualified Hydra.Core.Adapt as Adapt +import qualified Hydra.Core.Analysis as Analysis +import qualified Hydra.Core.Annotations as Annotations +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Constants as Constants +import qualified Hydra.Core.Decode.Model as DecodeModel +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Environment as Environment +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Math as Math +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Predicates as Predicates +import qualified Hydra.Core.Print.Errors as PrintErrors +import qualified Hydra.Core.Print.Model as PrintModel +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variables as Variables +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Protobuf.Environment as ProtobufEnvironment +import qualified Hydra.Ext.Protobuf.Language as Language +import qualified Hydra.Ext.Protobuf.Proto3 as Proto3 +import qualified Hydra.Ext.Protobuf.Serde as Serde +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M +import qualified Data.Set as S + +-- | Collect all structural type references (Either, Pair) from a list of types +collectStructuralTypes :: [Model.Type] -> S.Set ProtobufEnvironment.StructuralTypeRef +collectStructuralTypes types = + Lists.foldl (\acc -> \t -> Sets.union acc (collectStructuralTypesFromType t)) Sets.empty types + +-- | Collect structural type references from a single type +collectStructuralTypesFromType :: Model.Type -> S.Set ProtobufEnvironment.StructuralTypeRef +collectStructuralTypesFromType typ = + Rewriting.foldOverType Coders.TraversalOrderPre (\acc -> \t -> + let st = simplifyType t + in case st of + Model.TypeEither v0 -> Sets.insert (ProtobufEnvironment.StructuralTypeRefEither (Model.eitherTypeLeft v0, (Model.eitherTypeRight v0))) acc + Model.TypePair v0 -> Sets.insert (ProtobufEnvironment.StructuralTypeRefPair (Model.pairTypeFirst v0, (Model.pairTypeSecond v0))) acc + _ -> acc) Sets.empty typ + +-- | Construct a Protobuf file from a Hydra module and its type definitions +constructModule :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.Module -> [Packaging.TypeDefinition] -> Either Errors.Error Proto3.ProtoFile +constructModule cx g mod typeDefs = + + let ns_ = Packaging.moduleName mod + desc = Optionals.bind (Packaging.moduleMetadata mod) (\em -> Packaging.entityMetadataDescription em) + toDef = + \td -> + let name = Packaging.typeDefinitionName td + typ = Model.typeSchemeBody (Packaging.typeDefinitionBody td) + encodeDefEither = \n -> \t -> encodeDefinition cx g ns_ n t + flatTyp = flattenType typ + enc = encodeDefEither name + in case (Strip.deannotateType flatTyp) of + Model.TypeVariable _ -> enc flatTyp + _ -> Eithers.bind (Adapt.adaptTypeForLanguage Language.protobufLanguage flatTyp) (\adaptedType -> enc adaptedType) + types = Lists.map (\td -> Model.typeSchemeBody (Packaging.typeDefinitionBody td)) typeDefs + structRefs = collectStructuralTypes types + javaOptions = + [ + Proto3.Option { + Proto3.optionName = javaMultipleFilesOptionName, + Proto3.optionValue = (Proto3.ValueBoolean True)}, + Proto3.Option { + Proto3.optionName = javaPackageOptionName, + Proto3.optionValue = (Proto3.ValueString (Proto3.unPackageName (namespaceToPackageName ns_)))}] + descOption = + Proto3.Option { + Proto3.optionName = Serde.descriptionOptionName, + Proto3.optionValue = (Proto3.ValueString (Strings.concat2 (Optionals.match desc "" (\d -> Strings.concat2 d "\n\n")) Constants.warningAutoGeneratedFile))} + checkFieldType_wrapper = + \typ -> case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> case (Strip.deannotateType v0) of + Model.TypeLiteral _ -> True + _ -> False + _ -> False + checkFieldType_empty = \typ -> Predicates.isUnitType typ + checkFields = + \checkType -> \checkFieldType -> \ts -> Lists.foldl (\b -> \t -> Logic.or b (Rewriting.foldOverType Coders.TraversalOrderPre (\b2 -> \t2 -> Logic.or b2 ( + let checkResult = checkType t2 + in (Optionals.match checkResult (case t2 of + Model.TypeRecord v0 -> Lists.foldl (\b3 -> \f -> Logic.or b3 (checkFieldType (Strip.deannotateType (Model.fieldTypeType f)))) False v0 + Model.TypeUnion v0 -> Lists.foldl (\b3 -> \f -> Logic.or b3 (checkFieldType (Strip.deannotateType (Model.fieldTypeType f)))) False v0 + _ -> False) (\b3 -> b3)))) False t)) False ts + wrapperImport = + Logic.ifElse (checkFields (\_ -> Nothing) checkFieldType_wrapper types) [ + Proto3.FileReference "google/protobuf/wrappers.proto"] [] + emptyCheckType = \typ -> Logic.ifElse (isEnumDefinition typ) (Just False) Nothing + emptyImport = + Logic.ifElse (checkFields emptyCheckType checkFieldType_empty types) [ + Proto3.FileReference "google/protobuf/empty.proto"] [] + in (Eithers.bind (Analysis.moduleDependencyModuleNames (ProtobufEnvironment.encoderStateContext cx) g True False False False mod) (\schemaImports -> Eithers.bind (Eithers.mapList toDef typeDefs) (\definitions -> + let schemaImportList = Lists.map (\n -> namespaceToFileReference n) (Sets.toList schemaImports) + in (Eithers.bind (mapAccumResult (\cx0 -> \ref -> generateStructuralTypeMessage cx0 g ns_ ref) cx (Sets.toList structRefs)) (\helperResult -> + let helperDefs = Pairs.first helperResult + in (Right (Proto3.ProtoFile { + Proto3.protoFilePackage = (namespaceToPackageName ns_), + Proto3.protoFileImports = (Lists.concat [ + schemaImportList, + wrapperImport, + emptyImport]), + Proto3.protoFileTypes = (Lists.concat [ + helperDefs, + definitions]), + Proto3.protoFileOptions = (Lists.cons descOption javaOptions)}))))))) + +-- | Encode a Hydra type as a Protobuf definition +encodeDefinition :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> Model.Name -> Model.Type -> Either Errors.Error Proto3.Definition +encodeDefinition cx g localNs name typ = + + let cx1 = + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), + ProtobufEnvironment.encoderStateFieldIndex = 0} + cx2 = + Pairs.second ( + ProtobufEnvironment.encoderStateFieldIndex cx1, + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx1), + ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx1) 1)}) + toEitherString = \result -> result + encode = + \cx0 -> \options -> \t -> case (simplifyType t) of + Model.TypeRecord v0 -> Eithers.map (\md -> Proto3.DefinitionMessage md) (toEitherString (encodeRecordType cx0 g localNs options name v0)) + Model.TypeUnion v0 -> Logic.ifElse (isEnumDefinition t) (Eithers.map (\ed -> Proto3.DefinitionEnum ed) (toEitherString (encodeEnumDefinition cx0 g options name v0))) (encode cx0 options (Rewriting.wrapTypeToRecord (Model.TypeUnion v0))) + _ -> encode cx0 options (Rewriting.wrapTypeToRecord t) + in (Eithers.bind (toEitherString (findOptions cx g typ)) (\options -> encode cx2 options typ)) + +-- | Encode a Hydra union type as a Protobuf enum definition +encodeEnumDefinition :: ProtobufEnvironment.EncoderState -> Graph.Graph -> [Proto3.Option] -> Model.Name -> [Model.FieldType] -> Either Errors.Error Proto3.EnumDefinition +encodeEnumDefinition cx g options tname fts = + + let unspecifiedField = + Proto3.EnumValue { + Proto3.enumValueName = (encodeEnumValueName tname (Model.Name "unspecified")), + Proto3.enumValueNumber = 0, + Proto3.enumValueOptions = []} + encodeEnumField = + \field -> \idx -> + let fname = Model.fieldTypeName field + ftype = Model.fieldTypeType field + in (Eithers.bind (findOptions cx g ftype) (\opts -> Right (Proto3.EnumValue { + Proto3.enumValueName = (encodeEnumValueName tname fname), + Proto3.enumValueNumber = idx, + Proto3.enumValueOptions = opts}))) + indices = Math.range 1 (Math.add (Lists.length fts) 1) + in (Eithers.bind (Eithers.mapList (\p -> encodeEnumField (Pairs.first p) (Pairs.second p)) (Lists.zip fts indices)) (\values -> Right (Proto3.EnumDefinition { + Proto3.enumDefinitionName = (encodeTypeName tname), + Proto3.enumDefinitionValues = (Lists.cons unspecifiedField values), + Proto3.enumDefinitionOptions = options}))) + +-- | Encode an enum value name from type name and field name +encodeEnumValueName :: Model.Name -> Model.Name -> Proto3.EnumValueName +encodeEnumValueName tname fname = + + let prefix = Formatting.nonAlnumToUnderscores (Formatting.convertCaseCamelToUpperSnake (Names.localNameOf tname)) + suffix = Formatting.nonAlnumToUnderscores (Formatting.convertCaseCamelToUpperSnake (Model.unName fname)) + in (Proto3.EnumValueName (Strings.concat [ + prefix, + "_", + suffix])) + +-- | Encode a field name, optionally preserving the original case +encodeFieldName :: Bool -> Model.Name -> Proto3.FieldName +encodeFieldName preserve name = + Proto3.FieldName (Logic.ifElse preserve (Model.unName name) (Formatting.convertCaseCamelToLowerSnake (Model.unName name))) + +-- | Encode a Hydra field type as a Protobuf field +encodeFieldType :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> Model.FieldType -> Either Errors.Error (Proto3.Field, ProtobufEnvironment.EncoderState) +encodeFieldType cx g localNs ft = + + let fname = Model.fieldTypeName ft + ftype = Model.fieldTypeType ft + encodeType_ = + \cx0 -> \g0 -> \ns0 -> \typ -> case (simplifyType typ) of + Model.TypeEither v0 -> + let ref = ProtobufEnvironment.StructuralTypeRefEither (Model.eitherTypeLeft v0, (Model.eitherTypeRight v0)) + in (Right (Proto3.FieldTypeSimple (Proto3.SimpleTypeReference (structuralTypeName ns0 ref)))) + Model.TypePair v0 -> + let ref = ProtobufEnvironment.StructuralTypeRefPair (Model.pairTypeFirst v0, (Model.pairTypeSecond v0)) + in (Right (Proto3.FieldTypeSimple (Proto3.SimpleTypeReference (structuralTypeName ns0 ref)))) + Model.TypeList v0 -> Eithers.map (\st -> Proto3.FieldTypeRepeated st) (encodeSimpleType_ cx0 g0 ns0 True v0) + Model.TypeSet v0 -> Eithers.map (\st -> Proto3.FieldTypeRepeated st) (encodeSimpleType_ cx0 g0 ns0 True v0) + Model.TypeMap v0 -> Eithers.bind (encodeSimpleType_ cx0 g0 ns0 False (Model.mapTypeKeys v0)) (\kt -> Eithers.bind (encodeSimpleType_ cx0 g0 ns0 True (Model.mapTypeValues v0)) (\vt -> Right (Proto3.FieldTypeMap (Proto3.MapType { + Proto3.mapTypeKeys = kt, + Proto3.mapTypeValues = vt})))) + Model.TypeOptional v0 -> case (Strip.deannotateType v0) of + Model.TypeLiteral v1 -> Eithers.map (\st -> Proto3.FieldTypeSimple st) (encodeScalarTypeWrapped cx0 v1) + _ -> encodeType_ cx0 g0 ns0 v0 + Model.TypeUnion v0 -> Eithers.bind (mapAccumResult (\cx_ -> \f -> encodeFieldType cx_ g0 ns0 f) cx0 v0) (\pfields -> + let fields_ = Pairs.first pfields + in (Right (Proto3.FieldTypeOneof fields_))) + _ -> Eithers.map (\st -> Proto3.FieldTypeSimple st) (encodeSimpleType_ cx0 g0 ns0 True typ) + encodeSimpleType_ = + \cx0 -> \g0 -> \ns0 -> \noms -> \typ -> + let forNominal = \name -> Right (Proto3.SimpleTypeReference (encodeTypeReference ns0 name)) + in case (simplifyType typ) of + Model.TypeLiteral v0 -> Eithers.map (\st -> Proto3.SimpleTypeScalar st) (encodeScalarType cx0 v0) + Model.TypeRecord _ -> unexpectedE cx0 "named type reference" "anonymous record type" + Model.TypeUnion _ -> unexpectedE cx0 "named type reference" "anonymous union type" + Model.TypeUnit -> Right (Proto3.SimpleTypeReference (Proto3.TypeName "google.protobuf.Empty")) + Model.TypeVariable v0 -> Logic.ifElse noms (forNominal v0) (Eithers.bind (Lexical.requireBinding g0 v0) (\el -> + let term = Model.bindingTerm el + in (Eithers.bind (Eithers.bimap (\de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError de))) (\t -> t) (DecodeModel.type_ g0 term)) (\resolvedTyp -> encodeSimpleType_ cx0 g0 ns0 noms resolvedTyp)))) + _ -> unexpectedE cx0 "simple type" (PrintModel.type_ (Strip.removeTypeAnnotations typ)) + in (Eithers.bind (findOptions cx g ftype) (\options -> Eithers.bind (encodeType_ cx g localNs ftype) (\ft_ -> + let idxPair = + ( + ProtobufEnvironment.encoderStateFieldIndex cx, + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), + ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx) 1)}) + idx = Pairs.first idxPair + cx1 = Pairs.second idxPair + in (Eithers.bind (readBooleanAnnotation cx g Constants.keyPreserveFieldName ftype) (\preserve -> Right ( + Proto3.Field { + Proto3.fieldName = (encodeFieldName preserve fname), + Proto3.fieldJsonName = Nothing, + Proto3.fieldType = ft_, + Proto3.fieldNumber = idx, + Proto3.fieldOptions = options}, + cx1)))))) + +-- | Encode a Hydra record type as a Protobuf message definition +encodeRecordType :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> [Proto3.Option] -> Model.Name -> [Model.FieldType] -> Either Errors.Error Proto3.MessageDefinition +encodeRecordType cx g localNs options tname fts = + Eithers.bind (mapAccumResult (\cx_ -> \f -> encodeFieldType cx_ g localNs f) cx fts) (\result -> + let pfields = Pairs.first result + in (Right (Proto3.MessageDefinition { + Proto3.messageDefinitionName = (encodeTypeName tname), + Proto3.messageDefinitionFields = pfields, + Proto3.messageDefinitionOptions = options}))) + +-- | Encode a Hydra literal type as a Protobuf scalar type. Protobuf has no int8/int16/uint8/uint16/bigint scalar, so int8 and int16 widen (losslessly) to int32, uint8 and uint16 widen (losslessly) to uint32, and bigint narrows (lossily, matching the Avro coder's fallback) to int64. +encodeScalarType :: t0 -> Model.LiteralType -> Either Errors.Error Proto3.ScalarType +encodeScalarType cx lt = + case lt of + Model.LiteralTypeBinary -> Right Proto3.ScalarTypeBytes + Model.LiteralTypeBoolean -> Right Proto3.ScalarTypeBool + Model.LiteralTypeFloat v0 -> case v0 of + Model.FloatTypeFloat32 -> Right Proto3.ScalarTypeFloat + Model.FloatTypeFloat64 -> Right Proto3.ScalarTypeDouble + _ -> unexpectedE cx "32-bit or 64-bit floating-point type" (PrintModel.floatType v0) + Model.LiteralTypeInteger v0 -> case v0 of + Model.IntegerTypeBigint -> Right Proto3.ScalarTypeInt64 + Model.IntegerTypeInt8 -> Right Proto3.ScalarTypeInt32 + Model.IntegerTypeInt16 -> Right Proto3.ScalarTypeInt32 + Model.IntegerTypeInt32 -> Right Proto3.ScalarTypeInt32 + Model.IntegerTypeInt64 -> Right Proto3.ScalarTypeInt64 + Model.IntegerTypeUint8 -> Right Proto3.ScalarTypeUint32 + Model.IntegerTypeUint16 -> Right Proto3.ScalarTypeUint32 + Model.IntegerTypeUint32 -> Right Proto3.ScalarTypeUint32 + Model.IntegerTypeUint64 -> Right Proto3.ScalarTypeUint64 + _ -> unexpectedE cx "supported integer type" (PrintModel.integerType v0) + Model.LiteralTypeString -> Right Proto3.ScalarTypeString + _ -> unexpectedE cx "supported literal type" (PrintModel.literalType lt) + +-- | Encode a Hydra literal type as a wrapped Protobuf type (for optional scalars). Widths without a dedicated Protobuf wrapper type widen/narrow the same way as encodeScalarType. +encodeScalarTypeWrapped :: t0 -> Model.LiteralType -> Either Errors.Error Proto3.SimpleType +encodeScalarTypeWrapped cx lt = + + let toType = + \label -> Right (Proto3.SimpleTypeReference (Proto3.TypeName (Strings.concat [ + "google.protobuf.", + label, + "Value"]))) + in case lt of + Model.LiteralTypeBinary -> toType "Bytes" + Model.LiteralTypeBoolean -> toType "Bool" + Model.LiteralTypeFloat v0 -> case v0 of + Model.FloatTypeFloat32 -> toType "Float" + Model.FloatTypeFloat64 -> toType "Double" + _ -> unexpectedE cx "32-bit or 64-bit floating-point type" (PrintModel.floatType v0) + Model.LiteralTypeInteger v0 -> case v0 of + Model.IntegerTypeBigint -> toType "Int64" + Model.IntegerTypeInt8 -> toType "Int32" + Model.IntegerTypeInt16 -> toType "Int32" + Model.IntegerTypeInt32 -> toType "Int32" + Model.IntegerTypeInt64 -> toType "Int64" + Model.IntegerTypeUint8 -> toType "UInt32" + Model.IntegerTypeUint16 -> toType "UInt32" + Model.IntegerTypeUint32 -> toType "UInt32" + Model.IntegerTypeUint64 -> toType "UInt64" + _ -> unexpectedE cx "supported integer type" (PrintModel.integerType v0) + Model.LiteralTypeString -> toType "String" + _ -> unexpectedE cx "supported literal type" (PrintModel.literalType lt) + +-- | Encode a simple type for helper message fields +encodeSimpleTypeForHelper :: t0 -> Packaging.ModuleName -> Model.Type -> Either Errors.Error Proto3.SimpleType +encodeSimpleTypeForHelper cx localNs typ = + + let forNominal = \name -> Right (Proto3.SimpleTypeReference (encodeTypeReference localNs name)) + in case (simplifyType typ) of + Model.TypeLiteral v0 -> Eithers.map (\st -> Proto3.SimpleTypeScalar st) (encodeScalarType cx v0) + Model.TypeRecord _ -> unexpectedE cx "named type reference" "anonymous record type" + Model.TypeUnion _ -> unexpectedE cx "named type reference" "anonymous union type" + Model.TypeUnit -> Right (Proto3.SimpleTypeReference (Proto3.TypeName "google.protobuf.Empty")) + Model.TypeVariable v0 -> forNominal v0 + _ -> unexpectedE cx "simple type in structural type helper" (PrintModel.type_ (Strip.removeTypeAnnotations typ)) + +-- | Encode a Hydra type name as a Protobuf type name +encodeTypeName :: Model.Name -> Proto3.TypeName +encodeTypeName name = Proto3.TypeName (Names.localNameOf name) + +-- | Encode a Hydra name as a Protobuf type reference +encodeTypeReference :: Packaging.ModuleName -> Model.Name -> Proto3.TypeName +encodeTypeReference localNs name = + + let qn = Names.qualifyName name + local = Util.qualifiedNameLocal qn + ns_ = Util.qualifiedNameModuleName qn + localNsParts = Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName localNs))) + in (Proto3.TypeName (Optionals.match ns_ local (\nsVal -> + let nsParts = Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName nsVal))) + in (Logic.ifElse (Equality.equal nsParts localNsParts) local (Strings.join "." (Lists.concat [ + nsParts, + [ + local]])))))) + +-- | Construct a Left error result from an error message, ignoring the encoder state +err :: t0 -> String -> Either Errors.Error t1 +err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) + +-- | Find Protobuf options for a type (description and deprecated) +findOptions :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Model.Type -> Either Errors.Error [Proto3.Option] +findOptions cx g typ = + Eithers.bind (Annotations.getTypeDescription (ProtobufEnvironment.encoderStateContext cx) g typ) (\mdesc -> Eithers.bind (readBooleanAnnotation cx g Constants.keyDeprecated typ) (\bdep -> + let mdescAnn = + Optionals.map (\desc_ -> Proto3.Option { + Proto3.optionName = Serde.descriptionOptionName, + Proto3.optionValue = (Proto3.ValueString desc_)}) mdesc + mdepAnn = + Logic.ifElse bdep (Just (Proto3.Option { + Proto3.optionName = "deprecated", + Proto3.optionValue = (Proto3.ValueBoolean True)})) Nothing + in (Right (Optionals.givens [ + mdescAnn, + mdepAnn])))) + +-- | Eliminate type lambdas and type applications, replacing type variables with the string type +flattenType :: Model.Type -> Model.Type +flattenType typ = + Rewriting.rewriteType (\recurse -> \t -> case t of + Model.TypeForall v0 -> recurse (Variables.replaceFreeTypeVariable (Model.forallTypeParameter v0) (Model.TypeLiteral Model.LiteralTypeString) (Model.forallTypeBody v0)) + Model.TypeApplication v0 -> recurse (Model.applicationTypeFunction v0) + _ -> recurse t) typ + +-- | Convert an Either String result into an Either Error result +fromEitherString :: t0 -> Either String t1 -> Either Errors.Error t1 +fromEitherString cx e = Eithers.bimap (\msg -> Errors.ErrorOther (Errors.OtherError msg)) (\a -> a) e + +-- | Generate a helper message definition for a structural type +generateStructuralTypeMessage :: ProtobufEnvironment.EncoderState -> t0 -> Packaging.ModuleName -> ProtobufEnvironment.StructuralTypeRef -> Either Errors.Error (Proto3.Definition, ProtobufEnvironment.EncoderState) +generateStructuralTypeMessage cx g localNs ref = + + let cx1 = + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), + ProtobufEnvironment.encoderStateFieldIndex = 0} + cx2 = + Pairs.second ( + ProtobufEnvironment.encoderStateFieldIndex cx1, + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx1), + ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx1) 1)}) + makeField = + \cx0 -> \fname -> \ftyp -> Eithers.bind (encodeSimpleTypeForHelper cx0 localNs ftyp) (\ft -> + let idxPair = + ( + ProtobufEnvironment.encoderStateFieldIndex cx0, + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx0), + ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx0) 1)}) + idx = Pairs.first idxPair + cx1_ = Pairs.second idxPair + in (Right ( + Proto3.Field { + Proto3.fieldName = (Proto3.FieldName fname), + Proto3.fieldJsonName = Nothing, + Proto3.fieldType = (Proto3.FieldTypeSimple ft), + Proto3.fieldNumber = idx, + Proto3.fieldOptions = []}, + cx1_))) + in case ref of + ProtobufEnvironment.StructuralTypeRefEither v0 -> + let lt = Pairs.first v0 + rt = Pairs.second v0 + in (Eithers.bind (makeField cx2 "left" lt) (\leftResult -> + let leftField = Pairs.first leftResult + cx3 = Pairs.second leftResult + in (Eithers.bind (makeField cx3 "right" rt) (\rightResult -> + let rightField = Pairs.first rightResult + cx4 = Pairs.second rightResult + in (Right ( + Proto3.DefinitionMessage (Proto3.MessageDefinition { + Proto3.messageDefinitionName = (structuralTypeName localNs ref), + Proto3.messageDefinitionFields = [ + leftField, + rightField], + Proto3.messageDefinitionOptions = []}), + cx4)))))) + ProtobufEnvironment.StructuralTypeRefPair v0 -> + let ft = Pairs.first v0 + st = Pairs.second v0 + in (Eithers.bind (makeField cx2 "first" ft) (\firstResult -> + let firstField = Pairs.first firstResult + cx3 = Pairs.second firstResult + in (Eithers.bind (makeField cx3 "second" st) (\secondResult -> + let secondField = Pairs.first secondResult + cx4 = Pairs.second secondResult + in (Right ( + Proto3.DefinitionMessage (Proto3.MessageDefinition { + Proto3.messageDefinitionName = (structuralTypeName localNs ref), + Proto3.messageDefinitionFields = [ + firstField, + secondField], + Proto3.messageDefinitionOptions = []}), + cx4)))))) + +-- | Check if a type is an enum definition +isEnumDefinition :: Model.Type -> Bool +isEnumDefinition typ = + case (simplifyType typ) of + Model.TypeUnion v0 -> isEnumFields v0 + _ -> False + +-- | Check if all fields are unit types (i.e., this is an enum) +isEnumFields :: [Model.FieldType] -> Bool +isEnumFields fts = + Lists.foldl (\b -> \f -> Logic.and b (Predicates.isUnitType (simplifyType (Model.fieldTypeType f)))) True fts + +-- | The name of the Protobuf java_multiple_files option +javaMultipleFilesOptionName :: String +javaMultipleFilesOptionName = "java_multiple_files" + +-- | The name of the Protobuf java_package option +javaPackageOptionName :: String +javaPackageOptionName = "java_package" + +-- | Annotation key under which the assigned Protobuf field index is recorded +keyProtoFieldIndex :: Model.Name +keyProtoFieldIndex = Model.Name "proto_field_index" + +-- | Thread context through a list, accumulating results +mapAccumResult :: (t0 -> t1 -> Either t2 (t3, t0)) -> t0 -> [t1] -> Either t2 ([t3], t0) +mapAccumResult f cx0 xs = + Lists.foldl (\accE -> \x -> Eithers.bind accE (\accPair -> + let bs = Pairs.first accPair + cxN = Pairs.second accPair + in (Eithers.map (\resultPair -> ( + Lists.concat [ + bs, + [ + Pairs.first resultPair]], + (Pairs.second resultPair))) (f cxN x)))) (Right ([], cx0)) xs + +-- | Convert a Hydra module to Protocol Buffers v3 source files +moduleToProtobuf :: Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map String String) +moduleToProtobuf mod defs cx g = + + let ns_ = Packaging.moduleName mod + partitioned = Environment.partitionDefinitions defs + typeDefs = Pairs.first partitioned + es = + ProtobufEnvironment.EncoderState { + ProtobufEnvironment.encoderStateContext = cx, + ProtobufEnvironment.encoderStateFieldIndex = 0} + in (Eithers.bind (constructModule es g mod typeDefs) (\pfile -> + let content = Serialization.printExpr (Serialization.parenthesize (Serde.protoFileToExpr pfile)) + path = Proto3.unFileReference (namespaceToFileReference ns_) + in (Right (Maps.singleton path content)))) + +-- | Convert a Hydra namespace to a Protobuf file reference +namespaceToFileReference :: Packaging.ModuleName -> Proto3.FileReference +namespaceToFileReference ns_ = + + let pns = + Strings.join "/" (Lists.map (\s -> Formatting.convertCaseCamelToLowerSnake s) (Strings.splitOn "." (Packaging.unModuleName ns_))) + in (Proto3.FileReference (Strings.concat2 pns ".proto")) + +-- | Convert a Hydra namespace to a Protobuf package name +namespaceToPackageName :: Packaging.ModuleName -> Proto3.PackageName +namespaceToPackageName ns_ = + Proto3.PackageName (Strings.join "." (Lists.map (\s -> Formatting.convertCaseCamelToLowerSnake s) (Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName ns_)))))) + +-- | Read a boolean annotation from a type +readBooleanAnnotation :: t0 -> Graph.Graph -> Model.Name -> Model.Type -> Either Errors.Error Bool +readBooleanAnnotation cx g key typ = + Optionals.match (Maps.lookup key (Annotations.typeAnnotationInternal typ)) (Right False) (\term -> ExtractModel.boolean g term) + +-- | Simplify a type by removing annotations and unwrapping newtypes +simplifyType :: Model.Type -> Model.Type +simplifyType typ = + case (Strip.deannotateType typ) of + Model.TypeWrap v0 -> simplifyType v0 + _ -> Strip.deannotateType typ + +-- | Generate a message name for a structural type reference +structuralTypeName :: t0 -> ProtobufEnvironment.StructuralTypeRef -> Proto3.TypeName +structuralTypeName localNs ref = + + let typeSuffix = + \typ -> + let st = simplifyType typ + in case st of + Model.TypeLiteral v0 -> case v0 of + Model.LiteralTypeBinary -> "bytes" + Model.LiteralTypeBoolean -> "bool" + Model.LiteralTypeFloat v1 -> case v1 of + Model.FloatTypeFloat32 -> "float" + Model.FloatTypeFloat64 -> "double" + _ -> "float" + Model.LiteralTypeInteger v1 -> case v1 of + Model.IntegerTypeInt32 -> "int32" + Model.IntegerTypeInt64 -> "int64" + Model.IntegerTypeUint32 -> "uint32" + Model.IntegerTypeUint64 -> "uint64" + _ -> "int64" + Model.LiteralTypeString -> "string" + _ -> "value" + Model.TypeRecord _ -> "record" + Model.TypeUnion _ -> "union" + Model.TypeVariable v0 -> Names.localNameOf v0 + Model.TypeUnit -> "unit" + Model.TypeList _ -> "list" + Model.TypeSet _ -> "set" + Model.TypeMap _ -> "map" + Model.TypeOptional _ -> "optional" + _ -> "value" + in (Proto3.TypeName (case ref of + ProtobufEnvironment.StructuralTypeRefEither v0 -> Strings.concat [ + "Either_", + (typeSuffix (Pairs.first v0)), + "_", + (typeSuffix (Pairs.second v0))] + ProtobufEnvironment.StructuralTypeRefPair v0 -> Strings.concat [ + "Pair_", + (typeSuffix (Pairs.first v0)), + "_", + (typeSuffix (Pairs.second v0))])) + +-- | Construct an error reporting an expected construct versus what was actually found +unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 +unexpectedE cx expected found = + err cx (Strings.concat [ + "Expected ", + expected, + ", found: ", + found]) diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Environment.hs b/src/main/haskell/Hydra/Ext/Protobuf/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Environment.hs @@ -0,0 +1,40 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Type definitions for the Protobuf code generation environment + +module Hydra.Ext.Protobuf.Environment where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typing as Typing +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | State threaded through Protobuf encoding: inference context plus field-index counter +data EncoderState = + EncoderState { + -- | Inference context used by kernel utilities (annotations, dependency analysis) + encoderStateContext :: Typing.InferenceContext, + -- | Counter used to assign the next Protobuf field index within the current message + encoderStateFieldIndex :: Int} + deriving (Eq, Ord, Read, Show) + +_EncoderState = Model.Name "hydra.ext.protobuf.environment.EncoderState" + +_EncoderState_context = Model.Name "context" + +_EncoderState_fieldIndex = Model.Name "fieldIndex" + +-- | A reference to a structural type (Either or Pair) with its component types +data StructuralTypeRef = + -- | An Either type with left and right component types + StructuralTypeRefEither (Model.Type, Model.Type) | + -- | A Pair type with first and second component types + StructuralTypeRefPair (Model.Type, Model.Type) + deriving (Eq, Ord, Read, Show) + +_StructuralTypeRef = Model.Name "hydra.ext.protobuf.environment.StructuralTypeRef" + +_StructuralTypeRef_either = Model.Name "either" + +_StructuralTypeRef_pair = Model.Name "pair" diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Language.hs b/src/main/haskell/Hydra/Ext/Protobuf/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Language.hs @@ -0,0 +1,164 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints for Protobuf v3 + +module Hydra.Ext.Protobuf.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Set as S + +-- | Language constraints for Protocol Buffers v3 +protobufLanguage :: Coders.Language +protobufLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.protobuf"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "proto")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBinary, + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = + Sets.fromList [ + Model.FloatTypeFloat32, + Model.FloatTypeFloat64] + integerTypes = + Sets.fromList [ + Model.IntegerTypeInt32, + Model.IntegerTypeInt64, + Model.IntegerTypeUint32, + Model.IntegerTypeUint64] + termVariants = + Sets.fromList [ + Variants.TermVariantEither, + Variants.TermVariantList, + Variants.TermVariantLiteral, + Variants.TermVariantMap, + Variants.TermVariantOptional, + Variants.TermVariantPair, + Variants.TermVariantRecord, + Variants.TermVariantSet, + Variants.TermVariantInject, + Variants.TermVariantUnit, + Variants.TermVariantWrap] + typeVariants = + Sets.fromList [ + Variants.TypeVariantAnnotated, + Variants.TypeVariantEither, + Variants.TypeVariantList, + Variants.TypeVariantLiteral, + Variants.TypeVariantMap, + Variants.TypeVariantOptional, + Variants.TypeVariantPair, + Variants.TypeVariantRecord, + Variants.TypeVariantSet, + Variants.TypeVariantUnion, + Variants.TypeVariantUnit, + Variants.TypeVariantVariable, + Variants.TypeVariantVoid, + Variants.TypeVariantWrap] + typePredicate = + \typ -> case typ of + Model.TypeMap v0 -> + let valuesType = Model.mapTypeValues v0 + stripped = Strip.deannotateType valuesType + in case stripped of + Model.TypeOptional _ -> False + _ -> True + _ -> True + +-- | A set of reserved words in Protobuf +protobufReservedWords :: S.Set String +protobufReservedWords = Sets.fromList (Lists.concat [ + fieldNames]) + where + fieldNames = + [ + "case", + "class", + "data", + "default", + "deriving", + "do", + "else", + "foreign", + "if", + "import", + "in", + "infix", + "infixl", + "infixr", + "instance", + "let", + "mdo", + "module", + "newtype", + "of", + "pattern", + "proc", + "rec", + "then", + "type", + "where"] diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Proto3.hs b/src/main/haskell/Hydra/Ext/Protobuf/Proto3.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Proto3.hs @@ -0,0 +1,294 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for Protocol Buffers v3 enum and message types, designed as a target for transformations.This model is loosely based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/type.proto, as well as the proto3 reference documentation + +module Hydra.Ext.Protobuf.Proto3 where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | A top-level Protobuf definition, either an enum or a message type +data Definition = + DefinitionEnum EnumDefinition | + DefinitionMessage MessageDefinition + deriving (Eq, Ord, Read, Show) + +_Definition = Model.Name "hydra.ext.protobuf.proto3.Definition" + +_Definition_enum = Model.Name "enum" + +_Definition_message = Model.Name "message" + +-- | Enum type definition +data EnumDefinition = + EnumDefinition { + -- | Enum type name + enumDefinitionName :: TypeName, + -- | Enum value definitions + enumDefinitionValues :: [EnumValue], + -- | Protocol buffer options + enumDefinitionOptions :: [Option]} + deriving (Eq, Ord, Read, Show) + +_EnumDefinition = Model.Name "hydra.ext.protobuf.proto3.EnumDefinition" + +_EnumDefinition_name = Model.Name "name" + +_EnumDefinition_values = Model.Name "values" + +_EnumDefinition_options = Model.Name "options" + +-- | Enum value definition +data EnumValue = + EnumValue { + -- | Enum value name + enumValueName :: EnumValueName, + -- | Enum value number + enumValueNumber :: Int, + -- | Protocol buffer options + enumValueOptions :: [Option]} + deriving (Eq, Ord, Read, Show) + +_EnumValue = Model.Name "hydra.ext.protobuf.proto3.EnumValue" + +_EnumValue_name = Model.Name "name" + +_EnumValue_number = Model.Name "number" + +_EnumValue_options = Model.Name "options" + +-- | The name of an enum value, conventionally an upper-snake-case identifier +newtype EnumValueName = + EnumValueName { + unEnumValueName :: String} + deriving (Eq, Ord, Read, Show) + +_EnumValueName = Model.Name "hydra.ext.protobuf.proto3.EnumValueName" + +-- | A single field of a message type +data Field = + Field { + -- | The field name + fieldName :: FieldName, + -- | The field JSON name + fieldJsonName :: (Maybe String), + -- | The datatype of the field + fieldType :: FieldType, + -- | The field number + fieldNumber :: Int, + -- | The protocol buffer options + fieldOptions :: [Option]} + deriving (Eq, Ord, Read, Show) + +_Field = Model.Name "hydra.ext.protobuf.proto3.Field" + +_Field_name = Model.Name "name" + +_Field_jsonName = Model.Name "jsonName" + +_Field_type = Model.Name "type" + +_Field_number = Model.Name "number" + +_Field_options = Model.Name "options" + +-- | The name of a field +newtype FieldName = + FieldName { + unFieldName :: String} + deriving (Eq, Ord, Read, Show) + +_FieldName = Model.Name "hydra.ext.protobuf.proto3.FieldName" + +-- | The type of a message field: a map, a oneof group, a repeated field, or a simple field +data FieldType = + FieldTypeMap MapType | + FieldTypeOneof [Field] | + FieldTypeRepeated SimpleType | + FieldTypeSimple SimpleType + deriving (Eq, Ord, Read, Show) + +_FieldType = Model.Name "hydra.ext.protobuf.proto3.FieldType" + +_FieldType_map = Model.Name "map" + +_FieldType_oneof = Model.Name "oneof" + +_FieldType_repeated = Model.Name "repeated" + +_FieldType_simple = Model.Name "simple" + +-- | A path to a .proto file, as used in import statements +newtype FileReference = + FileReference { + unFileReference :: String} + deriving (Eq, Ord, Read, Show) + +_FileReference = Model.Name "hydra.ext.protobuf.proto3.FileReference" + +-- | The key and value types of a proto3 map field +data MapType = + MapType { + mapTypeKeys :: SimpleType, + mapTypeValues :: SimpleType} + deriving (Eq, Ord, Read, Show) + +_MapType = Model.Name "hydra.ext.protobuf.proto3.MapType" + +_MapType_keys = Model.Name "keys" + +_MapType_values = Model.Name "values" + +-- | A protocol buffer message type +data MessageDefinition = + MessageDefinition { + -- | The fully qualified message name + messageDefinitionName :: TypeName, + -- | The list of fields + messageDefinitionFields :: [Field], + -- | The protocol buffer options + messageDefinitionOptions :: [Option]} + deriving (Eq, Ord, Read, Show) + +_MessageDefinition = Model.Name "hydra.ext.protobuf.proto3.MessageDefinition" + +_MessageDefinition_name = Model.Name "name" + +_MessageDefinition_fields = Model.Name "fields" + +_MessageDefinition_options = Model.Name "options" + +-- | A protocol buffer option, which can be attached to a message, field, enumeration, etc +data Option = + Option { + -- | The option's name. For protobuf built-in options (options defined in descriptor.proto), this is the short name. For example, `"map_entry"`. For custom options, it should be the fully-qualified name. For example, `"google.api.http"`. + optionName :: String, + -- | The option's value + optionValue :: Value} + deriving (Eq, Ord, Read, Show) + +_Option = Model.Name "hydra.ext.protobuf.proto3.Option" + +_Option_name = Model.Name "name" + +_Option_value = Model.Name "value" + +-- | A Protobuf package name, i.e. the value of a package declaration +newtype PackageName = + PackageName { + unPackageName :: String} + deriving (Eq, Ord, Read, Show) + +_PackageName = Model.Name "hydra.ext.protobuf.proto3.PackageName" + +-- | A .proto file, usually containing one or more enum or message type definitions +data ProtoFile = + ProtoFile { + protoFilePackage :: PackageName, + protoFileImports :: [FileReference], + protoFileTypes :: [Definition], + protoFileOptions :: [Option]} + deriving (Eq, Ord, Read, Show) + +_ProtoFile = Model.Name "hydra.ext.protobuf.proto3.ProtoFile" + +_ProtoFile_package = Model.Name "package" + +_ProtoFile_imports = Model.Name "imports" + +_ProtoFile_types = Model.Name "types" + +_ProtoFile_options = Model.Name "options" + +-- | One of several Proto3 scalar types +data ScalarType = + ScalarTypeBool | + ScalarTypeBytes | + ScalarTypeDouble | + ScalarTypeFixed32 | + ScalarTypeFixed64 | + ScalarTypeFloat | + ScalarTypeInt32 | + ScalarTypeInt64 | + ScalarTypeSfixed32 | + ScalarTypeSfixed64 | + ScalarTypeSint32 | + ScalarTypeSint64 | + ScalarTypeString | + ScalarTypeUint32 | + ScalarTypeUint64 + deriving (Eq, Ord, Read, Show) + +_ScalarType = Model.Name "hydra.ext.protobuf.proto3.ScalarType" + +_ScalarType_bool = Model.Name "bool" + +_ScalarType_bytes = Model.Name "bytes" + +_ScalarType_double = Model.Name "double" + +_ScalarType_fixed32 = Model.Name "fixed32" + +_ScalarType_fixed64 = Model.Name "fixed64" + +_ScalarType_float = Model.Name "float" + +_ScalarType_int32 = Model.Name "int32" + +_ScalarType_int64 = Model.Name "int64" + +_ScalarType_sfixed32 = Model.Name "sfixed32" + +_ScalarType_sfixed64 = Model.Name "sfixed64" + +_ScalarType_sint32 = Model.Name "sint32" + +_ScalarType_sint64 = Model.Name "sint64" + +_ScalarType_string = Model.Name "string" + +_ScalarType_uint32 = Model.Name "uint32" + +_ScalarType_uint64 = Model.Name "uint64" + +-- | A scalar type or a reference to an enum type or message type +data SimpleType = + SimpleTypeReference TypeName | + SimpleTypeScalar ScalarType + deriving (Eq, Ord, Read, Show) + +_SimpleType = Model.Name "hydra.ext.protobuf.proto3.SimpleType" + +_SimpleType_reference = Model.Name "reference" + +_SimpleType_scalar = Model.Name "scalar" + +-- | The local name of an enum type or message type +newtype TypeName = + TypeName { + unTypeName :: String} + deriving (Eq, Ord, Read, Show) + +_TypeName = Model.Name "hydra.ext.protobuf.proto3.TypeName" + +-- | A reference to an enum type or message type +newtype TypeReference = + TypeReference { + unTypeReference :: String} + deriving (Eq, Ord, Read, Show) + +_TypeReference = Model.Name "hydra.ext.protobuf.proto3.TypeReference" + +-- | A scalar value +data Value = + ValueBoolean Bool | + ValueString String + deriving (Eq, Ord, Read, Show) + +_Value = Model.Name "hydra.ext.protobuf.proto3.Value" + +_Value_boolean = Model.Name "boolean" + +_Value_string = Model.Name "string" diff --git a/src/main/haskell/Hydra/Ext/Protobuf/Serde.hs b/src/main/haskell/Hydra/Ext/Protobuf/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/Serde.hs @@ -0,0 +1,296 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Serialization functions for converting Protocol Buffers v3 AST to abstract expressions + +module Hydra.Ext.Protobuf.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Serialization as Serialization +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Ext.Protobuf.Proto3 as Proto3 +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Convert a definition to an expression +definitionToExpr :: Proto3.Definition -> Ast.Expr +definitionToExpr def = + case def of + Proto3.DefinitionEnum v0 -> enumDefinitionToExpr v0 + Proto3.DefinitionMessage v0 -> messageDefinitionToExpr v0 + +-- | The name of the deprecated option +deprecatedOptionName :: String +deprecatedOptionName = "deprecated" + +-- | A special Protobuf option name for descriptions (documentation) +descriptionOptionName :: String +descriptionOptionName = "_description" + +-- | Convert an enum definition to an expression +enumDefinitionToExpr :: Proto3.EnumDefinition -> Ast.Expr +enumDefinitionToExpr ed = + + let name = Proto3.enumDefinitionName ed + values = Proto3.enumDefinitionValues ed + options = Proto3.enumDefinitionOptions ed + in (optDesc False options (Serialization.spaceSep [ + Serialization.cst "enum", + (Serialization.cst (Proto3.unTypeName name)), + (protoBlock (Lists.map enumValueToExpr values))])) + +-- | Convert an enum value to an expression +enumValueToExpr :: Proto3.EnumValue -> Ast.Expr +enumValueToExpr ev = + + let name = Proto3.enumValueName ev + number = Proto3.enumValueNumber ev + options = Proto3.enumValueOptions ev + in (optDesc False options (semi (Serialization.spaceSep [ + Serialization.cst (Proto3.unEnumValueName name), + (Serialization.cst "="), + (Serialization.cst (Literals.printInt32 number))]))) + +-- | Filter out internal options (those whose names start with underscore) +excludeInternalOptions :: [Proto3.Option] -> [Proto3.Option] +excludeInternalOptions opts = + Lists.filter (\opt -> Logic.not (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 (Proto3.optionName opt))) 95)) opts + +-- | Convert a field option to an expression +fieldOptionToExpr :: Proto3.Option -> Ast.Expr +fieldOptionToExpr opt = + + let name = Proto3.optionName opt + value = Proto3.optionValue opt + in (Serialization.spaceSep [ + Serialization.cst name, + (Serialization.cst "="), + (valueToExpr value)]) + +-- | Convert field options to an optional bracket-enclosed expression +fieldOptionsToExpr :: [Proto3.Option] -> Maybe Ast.Expr +fieldOptionsToExpr opts0 = + + let opts = excludeInternalOptions opts0 + in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.bracketList Serialization.inlineStyle (Lists.map fieldOptionToExpr opts)))) + +-- | Convert a field to an expression +fieldToExpr :: Proto3.Field -> Ast.Expr +fieldToExpr f = + + let name = Proto3.fieldName f + typ = Proto3.fieldType f + num = Proto3.fieldNumber f + options = Proto3.fieldOptions f + in (optDesc False options (case typ of + Proto3.FieldTypeOneof v0 -> Serialization.spaceSep [ + Serialization.cst "oneof", + (Serialization.cst (Proto3.unFieldName name)), + (protoBlock (Lists.map fieldToExpr v0))] + Proto3.FieldTypeMap v0 -> + let kt = Proto3.mapTypeKeys v0 + vt = Proto3.mapTypeValues v0 + in (semi (Serialization.spaceSep (Optionals.givens [ + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), + (fieldOptionsToExpr options)]))) + Proto3.FieldTypeRepeated _ -> semi (Serialization.spaceSep (Optionals.givens [ + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), + (fieldOptionsToExpr options)])) + Proto3.FieldTypeSimple _ -> semi (Serialization.spaceSep (Optionals.givens [ + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), + (fieldOptionsToExpr options)])))) + +-- | Convert a field type to an expression +fieldTypeToExpr :: Proto3.FieldType -> Ast.Expr +fieldTypeToExpr ftyp = + case ftyp of + Proto3.FieldTypeMap v0 -> + let kt = Proto3.mapTypeKeys v0 + vt = Proto3.mapTypeValues v0 + in (Serialization.noSep [ + Serialization.cst "map", + (Serialization.angleBracesList Serialization.inlineStyle [ + simpleTypeToExpr kt, + (simpleTypeToExpr vt)])]) + Proto3.FieldTypeRepeated v0 -> Serialization.spaceSep [ + Serialization.cst "repeated", + (simpleTypeToExpr v0)] + Proto3.FieldTypeSimple v0 -> simpleTypeToExpr v0 + Proto3.FieldTypeOneof _ -> Serialization.cst "oneof" + +-- | Convert a file-level option to an expression +fileOptionToExpr :: Proto3.Option -> Ast.Expr +fileOptionToExpr opt = + + let name = Proto3.optionName opt + value = Proto3.optionValue opt + in (semi (Serialization.spaceSep [ + Serialization.cst "option", + (Serialization.cst name), + (Serialization.cst "="), + (valueToExpr value)])) + +-- | Convert file-level options to an optional newline-separated expression +fileOptionsToExpr :: [Proto3.Option] -> Maybe Ast.Expr +fileOptionsToExpr opts0 = + + let opts = excludeInternalOptions opts0 + in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.newlineSep (Lists.map fileOptionToExpr opts)))) + +-- | Convert a file reference to an import expression +importToExpr :: Proto3.FileReference -> Ast.Expr +importToExpr ref = + semi (Serialization.spaceSep [ + Serialization.cst "import", + (Serialization.cst (Literals.printString (Proto3.unFileReference ref)))]) + +-- | Convert a message definition to an expression +messageDefinitionToExpr :: Proto3.MessageDefinition -> Ast.Expr +messageDefinitionToExpr md = + + let name = Proto3.messageDefinitionName md + fields = Proto3.messageDefinitionFields md + options = Proto3.messageDefinitionOptions md + in (optDesc False options (Serialization.spaceSep [ + Serialization.cst "message", + (Serialization.cst (Proto3.unTypeName name)), + (protoBlock (Lists.map fieldToExpr fields))])) + +-- | Prepend an optional description comment to an expression +optDesc :: Bool -> [Proto3.Option] -> Ast.Expr -> Ast.Expr +optDesc doubleNewline opts expr = + + let descs = Lists.filter (\opt -> Equality.equal (Proto3.optionName opt) "_description") opts + in (Optionals.match (Lists.head descs) expr (\firstDesc -> + let descValue = Proto3.optionValue firstDesc + descStr = + case descValue of + Proto3.ValueBoolean v0 -> Logic.ifElse v0 "true" "false" + Proto3.ValueString v0 -> v0 + commentLines = + Lists.map (\line -> Logic.ifElse (Equality.equal line "") "//" (Strings.concat2 "// " line)) (Formatting.lines descStr) + comment = Serialization.cst (Strings.join "\n" commentLines) + sep = + Logic.ifElse doubleNewline (Serialization.doubleNewlineSep [ + comment, + expr]) (Serialization.newlineSep [ + comment, + expr]) + in sep)) + +-- | Wrap expressions in a curly-braced block with double-newline separation +protoBlock :: [Ast.Expr] -> Ast.Expr +protoBlock exprs = + Serialization.brackets Serialization.curlyBraces Serialization.fullBlockStyle (Serialization.doubleNewlineSep exprs) + +-- | Convert a proto file to an expression +protoFileToExpr :: Proto3.ProtoFile -> Ast.Expr +protoFileToExpr pf = + + let pkg = Proto3.protoFilePackage pf + imports = Proto3.protoFileImports pf + defs = Proto3.protoFileTypes pf + options = Proto3.protoFileOptions pf + headerSec = + Optionals.given (Serialization.newlineSep [ + semi (Serialization.cst "syntax = \"proto3\""), + (semi (Serialization.spaceSep [ + Serialization.cst "package", + (Serialization.cst (Proto3.unPackageName pkg))]))]) + importsSec = + Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) + options1 = Lists.filter (\opt -> Logic.not (Equality.equal (Proto3.optionName opt) "_description")) options + optionsSec = fileOptionsToExpr options1 + defsSec = + Logic.ifElse (Lists.isEmpty defs) Nothing (Optionals.given (Serialization.doubleNewlineSep (Lists.map definitionToExpr defs))) + in (optDesc True options (Serialization.doubleNewlineSep (Optionals.givens [ + headerSec, + importsSec, + optionsSec, + defsSec]))) + +-- | Convert a scalar type to an expression +scalarTypeToExpr :: Proto3.ScalarType -> Ast.Expr +scalarTypeToExpr sct = + Serialization.cst (case sct of + Proto3.ScalarTypeBool -> "bool" + Proto3.ScalarTypeBytes -> "bytes" + Proto3.ScalarTypeDouble -> "double" + Proto3.ScalarTypeFixed32 -> "fixed32" + Proto3.ScalarTypeFixed64 -> "fixed64" + Proto3.ScalarTypeFloat -> "float" + Proto3.ScalarTypeInt32 -> "int32" + Proto3.ScalarTypeInt64 -> "int64" + Proto3.ScalarTypeSfixed32 -> "sfixed32" + Proto3.ScalarTypeSfixed64 -> "sfixed64" + Proto3.ScalarTypeSint32 -> "sint32" + Proto3.ScalarTypeSint64 -> "sint64" + Proto3.ScalarTypeString -> "string" + Proto3.ScalarTypeUint32 -> "uint32" + Proto3.ScalarTypeUint64 -> "uint64") + +-- | Append a semicolon to an expression +semi :: Ast.Expr -> Ast.Expr +semi e = + Serialization.noSep [ + e, + (Serialization.cst ";")] + +-- | Convert a simple type to an expression +simpleTypeToExpr :: Proto3.SimpleType -> Ast.Expr +simpleTypeToExpr st = + case st of + Proto3.SimpleTypeReference v0 -> Serialization.cst (Proto3.unTypeName v0) + Proto3.SimpleTypeScalar v0 -> scalarTypeToExpr v0 + +-- | Convert a value to an expression +valueToExpr :: Proto3.Value -> Ast.Expr +valueToExpr v = + Serialization.cst (case v of + Proto3.ValueBoolean v0 -> Logic.ifElse v0 "true" "false" + Proto3.ValueString v0 -> Literals.printString v0) diff --git a/src/main/haskell/Hydra/Ext/Protobuf/SourceContext.hs b/src/main/haskell/Hydra/Ext/Protobuf/SourceContext.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Protobuf/SourceContext.hs @@ -0,0 +1,21 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/source_context.proto + +module Hydra.Ext.Protobuf.SourceContext where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | `SourceContext` represents information about the source of a protobuf element, like the file in which it is defined. +data SourceContext = + SourceContext { + -- | The path-qualified name of the .proto file that contained the associated protobuf element. For example: `"google/protobuf/source_context.proto"`. + sourceContextFileName :: String} + deriving (Eq, Ord, Read, Show) + +_SourceContext = Model.Name "hydra.ext.protobuf.sourceContext.SourceContext" + +_SourceContext_fileName = Model.Name "fileName" diff --git a/src/main/haskell/Hydra/Ext/Sql/Syntax.hs b/src/main/haskell/Hydra/Ext/Sql/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Sql/Syntax.hs @@ -0,0 +1,1577 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A subset of ANSI SQL:2003, capturing selected productions of the BNF grammar provided at https://ronsavage.github.io/SQL/sql-2003-2.bnf.html, which is based on the Final Committee Draft (FCD) of ISO/IEC 9075-2:2003 + +module Hydra.Ext.Sql.Syntax where + +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | An approximate (floating-point) numeric literal, such as 1.5E10 +newtype ApproximateNumericLiteral = + ApproximateNumericLiteral { + unApproximateNumericLiteral :: String} + deriving (Eq, Ord, Read, Show) + +_ApproximateNumericLiteral = Model.Name "hydra.ext.sql.syntax.ApproximateNumericLiteral" + +-- | An approximate numeric type: FLOAT, REAL, or DOUBLE PRECISION +data ApproximateNumericType = + ApproximateNumericTypeFloat (Maybe Precision) | + ApproximateNumericTypeReal | + ApproximateNumericTypeDouble + deriving (Eq, Ord, Read, Show) + +_ApproximateNumericType = Model.Name "hydra.ext.sql.syntax.ApproximateNumericType" + +_ApproximateNumericType_float = Model.Name "float" + +_ApproximateNumericType_real = Model.Name "real" + +_ApproximateNumericType_double = Model.Name "double" + +-- | A single element of an array value +newtype ArrayElement = + ArrayElement { + unArrayElement :: ValueExpression} + deriving (Eq, Ord, Read, Show) + +_ArrayElement = Model.Name "hydra.ext.sql.syntax.ArrayElement" + +-- | A non-empty, comma-separated list of array elements +data ArrayElementList = + ArrayElementList { + arrayElementListFirst :: ArrayElement, + arrayElementListRest :: [ArrayElement]} + deriving (Eq, Ord, Read, Show) + +_ArrayElementList = Model.Name "hydra.ext.sql.syntax.ArrayElementList" + +_ArrayElementList_first = Model.Name "first" + +_ArrayElementList_rest = Model.Name "rest" + +-- | A reference to an element of an array by index +newtype ArrayElementReference = + ArrayElementReference { + unArrayElementReference :: ()} + deriving (Eq, Ord, Read, Show) + +_ArrayElementReference = Model.Name "hydra.ext.sql.syntax.ArrayElementReference" + +-- | An ARRAY collection type +newtype ArrayType = + ArrayType { + unArrayType :: ()} + deriving (Eq, Ord, Read, Show) + +_ArrayType = Model.Name "hydra.ext.sql.syntax.ArrayType" + +-- | A constructor for an array value, either by enumeration or by query +data ArrayValueConstructor = + ArrayValueConstructorEnumeration ArrayValueConstructorByEnumeration | + ArrayValueConstructorQuery ArrayValueConstructorByQuery + deriving (Eq, Ord, Read, Show) + +_ArrayValueConstructor = Model.Name "hydra.ext.sql.syntax.ArrayValueConstructor" + +_ArrayValueConstructor_enumeration = Model.Name "enumeration" + +_ArrayValueConstructor_query = Model.Name "query" + +-- | An array value constructed by explicitly enumerating its elements +data ArrayValueConstructorByEnumeration = + ArrayValueConstructorByEnumeration { + arrayValueConstructorByEnumerationLeftBracketOrTrigraph :: LeftBracketOrTrigraph, + arrayValueConstructorByEnumerationArrayElementList :: ArrayElementList, + arrayValueConstructorByEnumerationRightBracketOrTrigraph :: RightBracketOrTrigraph} + deriving (Eq, Ord, Read, Show) + +_ArrayValueConstructorByEnumeration = Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByEnumeration" + +_ArrayValueConstructorByEnumeration_LeftBracketOrTrigraph = Model.Name "LeftBracketOrTrigraph" + +_ArrayValueConstructorByEnumeration_ArrayElementList = Model.Name "ArrayElementList" + +_ArrayValueConstructorByEnumeration_RightBracketOrTrigraph = Model.Name "RightBracketOrTrigraph" + +-- | An array value constructed from the result of a query +newtype ArrayValueConstructorByQuery = + ArrayValueConstructorByQuery { + unArrayValueConstructorByQuery :: ()} + deriving (Eq, Ord, Read, Show) + +_ArrayValueConstructorByQuery = Model.Name "hydra.ext.sql.syntax.ArrayValueConstructorByQuery" + +-- | An expression that evaluates to an array value +newtype ArrayValueExpression = + ArrayValueExpression { + unArrayValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_ArrayValueExpression = Model.Name "hydra.ext.sql.syntax.ArrayValueExpression" + +-- | A clause introducing a table's contents as the result of a subquery +newtype AsSubqueryClause = + AsSubqueryClause { + unAsSubqueryClause :: ()} + deriving (Eq, Ord, Read, Show) + +_AsSubqueryClause = Model.Name "hydra.ext.sql.syntax.AsSubqueryClause" + +-- | A reference to an attribute or method of a structured value +newtype AttributeOrMethodReference = + AttributeOrMethodReference { + unAttributeOrMethodReference :: ()} + deriving (Eq, Ord, Read, Show) + +_AttributeOrMethodReference = Model.Name "hydra.ext.sql.syntax.AttributeOrMethodReference" + +-- | A binary large object string type: BINARY LARGE OBJECT or BLOB +data BinaryLargeObjectStringType = + BinaryLargeObjectStringTypeBinary (Maybe LargeObjectLength) | + BinaryLargeObjectStringTypeBlob (Maybe LargeObjectLength) + deriving (Eq, Ord, Read, Show) + +_BinaryLargeObjectStringType = Model.Name "hydra.ext.sql.syntax.BinaryLargeObjectStringType" + +_BinaryLargeObjectStringType_binary = Model.Name "binary" + +_BinaryLargeObjectStringType_blob = Model.Name "blob" + +-- | A binary string literal, e.g. X'FF00' +newtype BinaryStringLiteral = + BinaryStringLiteral { + unBinaryStringLiteral :: ()} + deriving (Eq, Ord, Read, Show) + +_BinaryStringLiteral = Model.Name "hydra.ext.sql.syntax.BinaryStringLiteral" + +-- | A boolean test, optionally negated with NOT +data BooleanFactor = + BooleanFactor { + booleanFactorNOT :: (Maybe ()), + booleanFactorBooleanTest :: BooleanTest} + deriving (Eq, Ord, Read, Show) + +_BooleanFactor = Model.Name "hydra.ext.sql.syntax.BooleanFactor" + +_BooleanFactor_NOT = Model.Name "NOT" + +_BooleanFactor_BooleanTest = Model.Name "BooleanTest" + +-- | A boolean literal: TRUE, FALSE, or UNKNOWN +data BooleanLiteral = + BooleanLiteralTRUE | + BooleanLiteralFALSE | + BooleanLiteralUNKNOWN + deriving (Eq, Ord, Read, Show) + +_BooleanLiteral = Model.Name "hydra.ext.sql.syntax.BooleanLiteral" + +_BooleanLiteral_TRUE = Model.Name "TRUE" + +_BooleanLiteral_FALSE = Model.Name "FALSE" + +_BooleanLiteral_UNKNOWN = Model.Name "UNKNOWN" + +-- | An operand of a boolean predicate +newtype BooleanPredicand = + BooleanPredicand { + unBooleanPredicand :: ()} + deriving (Eq, Ord, Read, Show) + +_BooleanPredicand = Model.Name "hydra.ext.sql.syntax.BooleanPredicand" + +-- | A boolean primary expression: either a predicate or a boolean predicand +data BooleanPrimary = + BooleanPrimaryPredicate Predicate | + BooleanPrimaryPredicand BooleanPredicand + deriving (Eq, Ord, Read, Show) + +_BooleanPrimary = Model.Name "hydra.ext.sql.syntax.BooleanPrimary" + +_BooleanPrimary_predicate = Model.Name "predicate" + +_BooleanPrimary_predicand = Model.Name "predicand" + +-- | A boolean term: a factor, or a conjunction of terms with AND +data BooleanTerm = + BooleanTermFactor BooleanFactor | + BooleanTermConjunction BooleanTermAnd + deriving (Eq, Ord, Read, Show) + +_BooleanTerm = Model.Name "hydra.ext.sql.syntax.BooleanTerm" + +_BooleanTerm_factor = Model.Name "factor" + +_BooleanTerm_conjunction = Model.Name "conjunction" + +-- | A conjunction of two boolean terms joined by AND +data BooleanTermAnd = + BooleanTermAnd { + booleanTermAndLhs :: BooleanTerm, + booleanTermAndRhs :: BooleanFactor} + deriving (Eq, Ord, Read, Show) + +_BooleanTermAnd = Model.Name "hydra.ext.sql.syntax.BooleanTermAnd" + +_BooleanTermAnd_lhs = Model.Name "lhs" + +_BooleanTermAnd_rhs = Model.Name "rhs" + +-- | A boolean primary, optionally compared against a truth value with IS +data BooleanTest = + BooleanTest { + booleanTestBooleanPrimary :: BooleanPrimary, + booleanTestSequence :: (Maybe BooleanTestSequenceOption)} + deriving (Eq, Ord, Read, Show) + +_BooleanTest = Model.Name "hydra.ext.sql.syntax.BooleanTest" + +_BooleanTest_BooleanPrimary = Model.Name "BooleanPrimary" + +_BooleanTest_Sequence = Model.Name "Sequence" + +-- | The IS [NOT] truth-value suffix of a boolean test +data BooleanTestSequenceOption = + BooleanTestSequenceOption { + booleanTestSequenceOptionNOT :: (Maybe ()), + booleanTestSequenceOptionTruthValue :: TruthValue} + deriving (Eq, Ord, Read, Show) + +_BooleanTestSequenceOption = Model.Name "hydra.ext.sql.syntax.BooleanTestSequenceOption" + +_BooleanTestSequenceOption_NOT = Model.Name "NOT" + +_BooleanTestSequenceOption_TruthValue = Model.Name "TruthValue" + +-- | The BOOLEAN data type +newtype BooleanType = + BooleanType { + unBooleanType :: ()} + deriving (Eq, Ord, Read, Show) + +_BooleanType = Model.Name "hydra.ext.sql.syntax.BooleanType" + +-- | A boolean value expression: a term, or a disjunction of terms with OR +data BooleanValueExpression = + BooleanValueExpressionTerm BooleanTerm | + BooleanValueExpressionDisjunction BooleanValueExpressionOr + deriving (Eq, Ord, Read, Show) + +_BooleanValueExpression = Model.Name "hydra.ext.sql.syntax.BooleanValueExpression" + +_BooleanValueExpression_term = Model.Name "term" + +_BooleanValueExpression_disjunction = Model.Name "disjunction" + +-- | A disjunction of two boolean value expressions joined by OR +data BooleanValueExpressionOr = + BooleanValueExpressionOr { + booleanValueExpressionOrLhs :: BooleanValueExpression, + booleanValueExpressionOrRhs :: BooleanTerm} + deriving (Eq, Ord, Read, Show) + +_BooleanValueExpressionOr = Model.Name "hydra.ext.sql.syntax.BooleanValueExpressionOr" + +_BooleanValueExpressionOr_lhs = Model.Name "lhs" + +_BooleanValueExpressionOr_rhs = Model.Name "rhs" + +-- | A CASE expression, selecting a result from among several alternatives +newtype CaseExpression = + CaseExpression { + unCaseExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_CaseExpression = Model.Name "hydra.ext.sql.syntax.CaseExpression" + +-- | A CAST expression, converting a value to a specified data type +newtype CastSpecification = + CastSpecification { + unCastSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_CastSpecification = Model.Name "hydra.ext.sql.syntax.CastSpecification" + +-- | The name of a character set +newtype CharacterSetSpecification = + CharacterSetSpecification { + unCharacterSetSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_CharacterSetSpecification = Model.Name "hydra.ext.sql.syntax.CharacterSetSpecification" + +-- | A character string literal, e.g. 'hello' +newtype CharacterStringLiteral = + CharacterStringLiteral { + unCharacterStringLiteral :: String} + deriving (Eq, Ord, Read, Show) + +_CharacterStringLiteral = Model.Name "hydra.ext.sql.syntax.CharacterStringLiteral" + +-- | A character string type: CHARACTER, VARCHAR, or CHARACTER LARGE OBJECT +data CharacterStringType = + CharacterStringTypeCharacter (Maybe Length) | + CharacterStringTypeChar (Maybe Length) | + CharacterStringTypeCharacterVarying Length | + CharacterStringTypeCharVarying Length | + CharacterStringTypeVarchar Length | + CharacterStringTypeCharacterLargeObject (Maybe LargeObjectLength) | + CharacterStringTypeCharLargeObject (Maybe LargeObjectLength) | + CharacterStringTypeClob (Maybe LargeObjectLength) + deriving (Eq, Ord, Read, Show) + +_CharacterStringType = Model.Name "hydra.ext.sql.syntax.CharacterStringType" + +_CharacterStringType_character = Model.Name "character" + +_CharacterStringType_char = Model.Name "char" + +_CharacterStringType_characterVarying = Model.Name "characterVarying" + +_CharacterStringType_charVarying = Model.Name "charVarying" + +_CharacterStringType_varchar = Model.Name "varchar" + +_CharacterStringType_characterLargeObject = Model.Name "characterLargeObject" + +_CharacterStringType_charLargeObject = Model.Name "charLargeObject" + +_CharacterStringType_clob = Model.Name "clob" + +-- | A COLLATE clause specifying the collation to apply to a character value +newtype CollateClause = + CollateClause { + unCollateClause :: ()} + deriving (Eq, Ord, Read, Show) + +_CollateClause = Model.Name "hydra.ext.sql.syntax.CollateClause" + +-- | A collection type: ARRAY or MULTISET +data CollectionType = + CollectionTypeArray ArrayType | + CollectionTypeMultiset MultisetType + deriving (Eq, Ord, Read, Show) + +_CollectionType = Model.Name "hydra.ext.sql.syntax.CollectionType" + +_CollectionType_array = Model.Name "array" + +_CollectionType_multiset = Model.Name "multiset" + +-- | A constructor for a collection value: an array or multiset constructor +data CollectionValueConstructor = + CollectionValueConstructorArray ArrayValueConstructor | + CollectionValueConstructorMultiset MultisetValueConstructor + deriving (Eq, Ord, Read, Show) + +_CollectionValueConstructor = Model.Name "hydra.ext.sql.syntax.CollectionValueConstructor" + +_CollectionValueConstructor_array = Model.Name "array" + +_CollectionValueConstructor_multiset = Model.Name "multiset" + +-- | An expression that evaluates to a collection value +data CollectionValueExpression = + CollectionValueExpressionArray ArrayValueExpression | + CollectionValueExpressionMultiset MultisetValueExpression + deriving (Eq, Ord, Read, Show) + +_CollectionValueExpression = Model.Name "hydra.ext.sql.syntax.CollectionValueExpression" + +_CollectionValueExpression_array = Model.Name "array" + +_CollectionValueExpression_multiset = Model.Name "multiset" + +-- | A constraint attached to a single column definition +newtype ColumnConstraintDefinition = + ColumnConstraintDefinition { + unColumnConstraintDefinition :: ()} + deriving (Eq, Ord, Read, Show) + +_ColumnConstraintDefinition = Model.Name "hydra.ext.sql.syntax.ColumnConstraintDefinition" + +-- | The definition of a single column within a table definition +data ColumnDefinition = + ColumnDefinition { + columnDefinitionName :: ColumnName, + columnDefinitionTypeOrDomain :: (Maybe ColumnDefinitionTypeOrDomainOption), + columnDefinitionRefScope :: (Maybe ReferenceScopeCheck), + columnDefinitionDefaultOrIdentityOrGeneration :: (Maybe ColumnDefinitionDefaultOrIdentityOrGenerationOption), + columnDefinitionConstraints :: [ColumnConstraintDefinition], + columnDefinitionCollate :: (Maybe CollateClause)} + deriving (Eq, Ord, Read, Show) + +_ColumnDefinition = Model.Name "hydra.ext.sql.syntax.ColumnDefinition" + +_ColumnDefinition_name = Model.Name "name" + +_ColumnDefinition_typeOrDomain = Model.Name "typeOrDomain" + +_ColumnDefinition_refScope = Model.Name "refScope" + +_ColumnDefinition_defaultOrIdentityOrGeneration = Model.Name "defaultOrIdentityOrGeneration" + +_ColumnDefinition_constraints = Model.Name "constraints" + +_ColumnDefinition_collate = Model.Name "collate" + +-- | A column's default value, identity, or generation specification +data ColumnDefinitionDefaultOrIdentityOrGenerationOption = + ColumnDefinitionDefaultOrIdentityOrGenerationOptionDefaultClause DefaultClause | + ColumnDefinitionDefaultOrIdentityOrGenerationOptionIdentityColumnSpecification IdentityColumnSpecification | + ColumnDefinitionDefaultOrIdentityOrGenerationOptionGenerationClause GenerationClause + deriving (Eq, Ord, Read, Show) + +_ColumnDefinitionDefaultOrIdentityOrGenerationOption = + Model.Name "hydra.ext.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption" + +_ColumnDefinitionDefaultOrIdentityOrGenerationOption_DefaultClause = Model.Name "DefaultClause" + +_ColumnDefinitionDefaultOrIdentityOrGenerationOption_IdentityColumnSpecification = + Model.Name "IdentityColumnSpecification" + +_ColumnDefinitionDefaultOrIdentityOrGenerationOption_GenerationClause = Model.Name "GenerationClause" + +-- | A column's declared data type or domain +data ColumnDefinitionTypeOrDomainOption = + ColumnDefinitionTypeOrDomainOptionDataType DataType | + ColumnDefinitionTypeOrDomainOptionDomainName DomainName + deriving (Eq, Ord, Read, Show) + +_ColumnDefinitionTypeOrDomainOption = Model.Name "hydra.ext.sql.syntax.ColumnDefinitionTypeOrDomainOption" + +_ColumnDefinitionTypeOrDomainOption_DataType = Model.Name "DataType" + +_ColumnDefinitionTypeOrDomainOption_DomainName = Model.Name "DomainName" + +-- | The name of a table column +newtype ColumnName = + ColumnName { + unColumnName :: String} + deriving (Eq, Ord, Read, Show) + +_ColumnName = Model.Name "hydra.ext.sql.syntax.ColumnName" + +-- | A non-empty, comma-separated list of column names +data ColumnNameList = + ColumnNameList { + columnNameListFirst :: ColumnName, + columnNameListRest :: [ColumnName]} + deriving (Eq, Ord, Read, Show) + +_ColumnNameList = Model.Name "hydra.ext.sql.syntax.ColumnNameList" + +_ColumnNameList_first = Model.Name "first" + +_ColumnNameList_rest = Model.Name "rest" + +-- | The WITH OPTIONS clause of a column definition inherited via LIKE +newtype ColumnOptions = + ColumnOptions { + unColumnOptions :: ()} + deriving (Eq, Ord, Read, Show) + +_ColumnOptions = Model.Name "hydra.ext.sql.syntax.ColumnOptions" + +-- | A reference to a column, optionally qualified by a table or correlation name +newtype ColumnReference = + ColumnReference { + unColumnReference :: ()} + deriving (Eq, Ord, Read, Show) + +_ColumnReference = Model.Name "hydra.ext.sql.syntax.ColumnReference" + +-- | A value expression common to numeric, string, datetime, interval, user-defined, reference, and collection types +data CommonValueExpression = + CommonValueExpressionNumeric NumericValueExpression | + CommonValueExpressionString StringValueExpression | + CommonValueExpressionDatetime DatetimeValueExpression | + CommonValueExpressionInterval IntervalValueExpression | + CommonValueExpressionUserDefined UserDefinedTypeValueExpression | + CommonValueExpressionReference ReferenceValueExpression | + CommonValueExpressionCollection CollectionValueExpression + deriving (Eq, Ord, Read, Show) + +_CommonValueExpression = Model.Name "hydra.ext.sql.syntax.CommonValueExpression" + +_CommonValueExpression_numeric = Model.Name "numeric" + +_CommonValueExpression_string = Model.Name "string" + +_CommonValueExpression_datetime = Model.Name "datetime" + +_CommonValueExpression_interval = Model.Name "interval" + +_CommonValueExpression_userDefined = Model.Name "userDefined" + +_CommonValueExpression_reference = Model.Name "reference" + +_CommonValueExpression_collection = Model.Name "collection" + +-- | A row value constructor whose element types are inferred from context +newtype ContextuallyTypedRowValueConstructor = + ContextuallyTypedRowValueConstructor { + unContextuallyTypedRowValueConstructor :: ()} + deriving (Eq, Ord, Read, Show) + +_ContextuallyTypedRowValueConstructor = Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueConstructor" + +-- | A contextually typed row value expression: a special case or a constructor +data ContextuallyTypedRowValueExpression = + ContextuallyTypedRowValueExpressionSpecialCase RowValueSpecialCase | + ContextuallyTypedRowValueExpressionConstructor ContextuallyTypedRowValueConstructor + deriving (Eq, Ord, Read, Show) + +_ContextuallyTypedRowValueExpression = Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpression" + +_ContextuallyTypedRowValueExpression_specialCase = Model.Name "specialCase" + +_ContextuallyTypedRowValueExpression_constructor = Model.Name "constructor" + +-- | A non-empty, comma-separated list of contextually typed row value expressions +data ContextuallyTypedRowValueExpressionList = + ContextuallyTypedRowValueExpressionList { + contextuallyTypedRowValueExpressionListFirst :: ContextuallyTypedRowValueExpression, + contextuallyTypedRowValueExpressionListRest :: [ContextuallyTypedRowValueExpression]} + deriving (Eq, Ord, Read, Show) + +_ContextuallyTypedRowValueExpressionList = Model.Name "hydra.ext.sql.syntax.ContextuallyTypedRowValueExpressionList" + +_ContextuallyTypedRowValueExpressionList_first = Model.Name "first" + +_ContextuallyTypedRowValueExpressionList_rest = Model.Name "rest" + +-- | A table value constructor built from a list of contextually typed row values +newtype ContextuallyTypedTableValueConstructor = + ContextuallyTypedTableValueConstructor { + unContextuallyTypedTableValueConstructor :: ContextuallyTypedRowValueExpressionList} + deriving (Eq, Ord, Read, Show) + +_ContextuallyTypedTableValueConstructor = Model.Name "hydra.ext.sql.syntax.ContextuallyTypedTableValueConstructor" + +-- | A data type: predefined, row, named, reference, or collection +data DataType = + DataTypePredefined PredefinedType | + DataTypeRow RowType | + DataTypeNamed PathResolvedUserDefinedTypeName | + DataTypeReference ReferenceType | + DataTypeCollection CollectionType + deriving (Eq, Ord, Read, Show) + +_DataType = Model.Name "hydra.ext.sql.syntax.DataType" + +_DataType_predefined = Model.Name "predefined" + +_DataType_row = Model.Name "row" + +_DataType_named = Model.Name "named" + +_DataType_reference = Model.Name "reference" + +_DataType_collection = Model.Name "collection" + +-- | A DATE literal +newtype DateLiteral = + DateLiteral { + unDateLiteral :: DateString} + deriving (Eq, Ord, Read, Show) + +_DateLiteral = Model.Name "hydra.ext.sql.syntax.DateLiteral" + +-- | The string representation of a date literal, e.g. '2003-01-01' +newtype DateString = + DateString { + unDateString :: ()} + deriving (Eq, Ord, Read, Show) + +_DateString = Model.Name "hydra.ext.sql.syntax.DateString" + +-- | A datetime literal: a date, time, or timestamp literal +data DatetimeLiteral = + DatetimeLiteralDate DateLiteral | + DatetimeLiteralTime TimeLiteral | + DatetimeLiteralTimestamp TimestampLiteral + deriving (Eq, Ord, Read, Show) + +_DatetimeLiteral = Model.Name "hydra.ext.sql.syntax.DatetimeLiteral" + +_DatetimeLiteral_date = Model.Name "date" + +_DatetimeLiteral_time = Model.Name "time" + +_DatetimeLiteral_timestamp = Model.Name "timestamp" + +-- | A datetime type: DATE, TIME, or TIMESTAMP +newtype DatetimeType = + DatetimeType { + unDatetimeType :: ()} + deriving (Eq, Ord, Read, Show) + +_DatetimeType = Model.Name "hydra.ext.sql.syntax.DatetimeType" + +-- | An expression that evaluates to a datetime value +newtype DatetimeValueExpression = + DatetimeValueExpression { + unDatetimeValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_DatetimeValueExpression = Model.Name "hydra.ext.sql.syntax.DatetimeValueExpression" + +-- | A DEFAULT clause specifying a column's default value +newtype DefaultClause = + DefaultClause { + unDefaultClause :: ()} + deriving (Eq, Ord, Read, Show) + +_DefaultClause = Model.Name "hydra.ext.sql.syntax.DefaultClause" + +-- | The name of a user-defined domain +newtype DomainName = + DomainName { + unDomainName :: String} + deriving (Eq, Ord, Read, Show) + +_DomainName = Model.Name "hydra.ext.sql.syntax.DomainName" + +-- | An exact numeric literal, such as an integer or fixed-point decimal +newtype ExactNumericLiteral = + ExactNumericLiteral { + unExactNumericLiteral :: String} + deriving (Eq, Ord, Read, Show) + +_ExactNumericLiteral = Model.Name "hydra.ext.sql.syntax.ExactNumericLiteral" + +-- | An exact numeric type: NUMERIC, DECIMAL, DEC, SMALLINT, INTEGER, INT, or BIGINT +data ExactNumericType = + ExactNumericTypeNumeric (Maybe ExactNumericTypeNumericOption) | + ExactNumericTypeDecimal (Maybe ExactNumericTypeDecimalOption) | + ExactNumericTypeDec (Maybe ExactNumericTypeDecOption) | + ExactNumericTypeSmallint | + ExactNumericTypeInteger | + ExactNumericTypeInt | + ExactNumericTypeBigint + deriving (Eq, Ord, Read, Show) + +_ExactNumericType = Model.Name "hydra.ext.sql.syntax.ExactNumericType" + +_ExactNumericType_numeric = Model.Name "numeric" + +_ExactNumericType_decimal = Model.Name "decimal" + +_ExactNumericType_dec = Model.Name "dec" + +_ExactNumericType_smallint = Model.Name "smallint" + +_ExactNumericType_integer = Model.Name "integer" + +_ExactNumericType_int = Model.Name "int" + +_ExactNumericType_bigint = Model.Name "bigint" + +-- | The precision and optional scale of a DEC type +data ExactNumericTypeDecOption = + ExactNumericTypeDecOption { + exactNumericTypeDecOptionPrecision :: Precision, + exactNumericTypeDecOptionSequence :: (Maybe Scale)} + deriving (Eq, Ord, Read, Show) + +_ExactNumericTypeDecOption = Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecOption" + +_ExactNumericTypeDecOption_Precision = Model.Name "Precision" + +_ExactNumericTypeDecOption_Sequence = Model.Name "Sequence" + +-- | The precision and optional scale of a DECIMAL type +data ExactNumericTypeDecimalOption = + ExactNumericTypeDecimalOption { + exactNumericTypeDecimalOptionPrecision :: Precision, + exactNumericTypeDecimalOptionSequence :: (Maybe Scale)} + deriving (Eq, Ord, Read, Show) + +_ExactNumericTypeDecimalOption = Model.Name "hydra.ext.sql.syntax.ExactNumericTypeDecimalOption" + +_ExactNumericTypeDecimalOption_Precision = Model.Name "Precision" + +_ExactNumericTypeDecimalOption_Sequence = Model.Name "Sequence" + +-- | The precision and optional scale of a NUMERIC type +data ExactNumericTypeNumericOption = + ExactNumericTypeNumericOption { + exactNumericTypeNumericOptionPrecision :: Precision, + exactNumericTypeNumericOptionSequence :: (Maybe Scale)} + deriving (Eq, Ord, Read, Show) + +_ExactNumericTypeNumericOption = Model.Name "hydra.ext.sql.syntax.ExactNumericTypeNumericOption" + +_ExactNumericTypeNumericOption_Precision = Model.Name "Precision" + +_ExactNumericTypeNumericOption_Sequence = Model.Name "Sequence" + +-- | A reference to a field of a row or structured value +newtype FieldReference = + FieldReference { + unFieldReference :: ()} + deriving (Eq, Ord, Read, Show) + +_FieldReference = Model.Name "hydra.ext.sql.syntax.FieldReference" + +-- | An INSERT source specified by an explicit value constructor, with optional column list and override clause +data FromConstructor = + FromConstructor { + fromConstructorColumns :: (Maybe InsertColumnList), + fromConstructorOverride :: (Maybe OverrideClause), + fromConstructorValues :: ContextuallyTypedTableValueConstructor} + deriving (Eq, Ord, Read, Show) + +_FromConstructor = Model.Name "hydra.ext.sql.syntax.FromConstructor" + +_FromConstructor_columns = Model.Name "columns" + +_FromConstructor_override = Model.Name "override" + +_FromConstructor_values = Model.Name "values" + +-- | An INSERT source specified as DEFAULT VALUES +newtype FromDefault = + FromDefault { + unFromDefault :: ()} + deriving (Eq, Ord, Read, Show) + +_FromDefault = Model.Name "hydra.ext.sql.syntax.FromDefault" + +-- | An INSERT source specified as the result of a subquery +newtype FromSubquery = + FromSubquery { + unFromSubquery :: ()} + deriving (Eq, Ord, Read, Show) + +_FromSubquery = Model.Name "hydra.ext.sql.syntax.FromSubquery" + +-- | A general literal: a string, datetime, interval, or boolean literal +data GeneralLiteral = + GeneralLiteralString CharacterStringLiteral | + GeneralLiteralNationalString NationalCharacterStringLiteral | + GeneralLiteralUnicode UnicodeCharacterStringLiteral | + GeneralLiteralBinary BinaryStringLiteral | + GeneralLiteralDateTime DatetimeLiteral | + GeneralLiteralInterval IntervalLiteral | + GeneralLiteralBoolean BooleanLiteral + deriving (Eq, Ord, Read, Show) + +_GeneralLiteral = Model.Name "hydra.ext.sql.syntax.GeneralLiteral" + +_GeneralLiteral_string = Model.Name "string" + +_GeneralLiteral_nationalString = Model.Name "nationalString" + +_GeneralLiteral_unicode = Model.Name "unicode" + +_GeneralLiteral_binary = Model.Name "binary" + +_GeneralLiteral_dateTime = Model.Name "dateTime" + +_GeneralLiteral_interval = Model.Name "interval" + +_GeneralLiteral_boolean = Model.Name "boolean" + +-- | A general value specification, such as a parameter or dynamic value +newtype GeneralValueSpecification = + GeneralValueSpecification { + unGeneralValueSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_GeneralValueSpecification = Model.Name "hydra.ext.sql.syntax.GeneralValueSpecification" + +-- | A GENERATED ALWAYS AS clause for a computed column +newtype GenerationClause = + GenerationClause { + unGenerationClause :: ()} + deriving (Eq, Ord, Read, Show) + +_GenerationClause = Model.Name "hydra.ext.sql.syntax.GenerationClause" + +-- | The GLOBAL or LOCAL qualifier of a temporary table scope +data GlobalOrLocal = + GlobalOrLocalGlobal | + GlobalOrLocalLocal + deriving (Eq, Ord, Read, Show) + +_GlobalOrLocal = Model.Name "hydra.ext.sql.syntax.GlobalOrLocal" + +_GlobalOrLocal_global = Model.Name "global" + +_GlobalOrLocal_local = Model.Name "local" + +-- | A GENERATED ... AS IDENTITY column specification +newtype IdentityColumnSpecification = + IdentityColumnSpecification { + unIdentityColumnSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_IdentityColumnSpecification = Model.Name "hydra.ext.sql.syntax.IdentityColumnSpecification" + +-- | The parenthesized list of target column names in an INSERT statement +newtype InsertColumnList = + InsertColumnList { + unInsertColumnList :: ColumnNameList} + deriving (Eq, Ord, Read, Show) + +_InsertColumnList = Model.Name "hydra.ext.sql.syntax.InsertColumnList" + +-- | The column list and value source of an INSERT statement: a subquery, constructor, or default +data InsertColumnsAndSource = + InsertColumnsAndSourceSubquery FromSubquery | + InsertColumnsAndSourceConstructor FromConstructor | + InsertColumnsAndSourceDefault FromDefault + deriving (Eq, Ord, Read, Show) + +_InsertColumnsAndSource = Model.Name "hydra.ext.sql.syntax.InsertColumnsAndSource" + +_InsertColumnsAndSource_subquery = Model.Name "subquery" + +_InsertColumnsAndSource_constructor = Model.Name "constructor" + +_InsertColumnsAndSource_default = Model.Name "default" + +-- | An ANSI SQL INSERT statement +data InsertStatement = + InsertStatement { + insertStatementTarget :: InsertionTarget, + insertStatementColumnsAndSource :: InsertColumnsAndSource} + deriving (Eq, Ord, Read, Show) + +_InsertStatement = Model.Name "hydra.ext.sql.syntax.InsertStatement" + +_InsertStatement_target = Model.Name "target" + +_InsertStatement_columnsAndSource = Model.Name "columnsAndSource" + +-- | The table into which an INSERT statement inserts rows +newtype InsertionTarget = + InsertionTarget { + unInsertionTarget :: TableName} + deriving (Eq, Ord, Read, Show) + +_InsertionTarget = Model.Name "hydra.ext.sql.syntax.InsertionTarget" + +-- | An INTERVAL literal +newtype IntervalLiteral = + IntervalLiteral { + unIntervalLiteral :: ()} + deriving (Eq, Ord, Read, Show) + +_IntervalLiteral = Model.Name "hydra.ext.sql.syntax.IntervalLiteral" + +-- | The INTERVAL data type +newtype IntervalType = + IntervalType { + unIntervalType :: ()} + deriving (Eq, Ord, Read, Show) + +_IntervalType = Model.Name "hydra.ext.sql.syntax.IntervalType" + +-- | An expression that evaluates to an interval value +newtype IntervalValueExpression = + IntervalValueExpression { + unIntervalValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_IntervalValueExpression = Model.Name "hydra.ext.sql.syntax.IntervalValueExpression" + +-- | The length specification of a large object type, e.g. 1K, 1M, or 1G +newtype LargeObjectLength = + LargeObjectLength { + unLargeObjectLength :: ()} + deriving (Eq, Ord, Read, Show) + +_LargeObjectLength = Model.Name "hydra.ext.sql.syntax.LargeObjectLength" + +-- | A left square bracket, or its trigraph equivalent ??( +newtype LeftBracketOrTrigraph = + LeftBracketOrTrigraph { + unLeftBracketOrTrigraph :: String} + deriving (Eq, Ord, Read, Show) + +_LeftBracketOrTrigraph = Model.Name "hydra.ext.sql.syntax.LeftBracketOrTrigraph" + +-- | The length specification of a character or binary string type +newtype Length = + Length { + unLength :: UnsignedInteger} + deriving (Eq, Ord, Read, Show) + +_Length = Model.Name "hydra.ext.sql.syntax.Length" + +-- | A LIKE clause, copying column definitions from another table +newtype LikeClause = + LikeClause { + unLikeClause :: ()} + deriving (Eq, Ord, Read, Show) + +_LikeClause = Model.Name "hydra.ext.sql.syntax.LikeClause" + +-- | An invocation of a method on a structured value +newtype MethodInvocation = + MethodInvocation { + unMethodInvocation :: ()} + deriving (Eq, Ord, Read, Show) + +_MethodInvocation = Model.Name "hydra.ext.sql.syntax.MethodInvocation" + +-- | A reference to an element of a multiset by way of the ELEMENT function +newtype MultisetElementReference = + MultisetElementReference { + unMultisetElementReference :: ()} + deriving (Eq, Ord, Read, Show) + +_MultisetElementReference = Model.Name "hydra.ext.sql.syntax.MultisetElementReference" + +-- | A MULTISET collection type over a given element data type +newtype MultisetType = + MultisetType { + unMultisetType :: DataType} + deriving (Eq, Ord, Read, Show) + +_MultisetType = Model.Name "hydra.ext.sql.syntax.MultisetType" + +-- | A constructor for a multiset value +newtype MultisetValueConstructor = + MultisetValueConstructor { + unMultisetValueConstructor :: ()} + deriving (Eq, Ord, Read, Show) + +_MultisetValueConstructor = Model.Name "hydra.ext.sql.syntax.MultisetValueConstructor" + +-- | An expression that evaluates to a multiset value +newtype MultisetValueExpression = + MultisetValueExpression { + unMultisetValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_MultisetValueExpression = Model.Name "hydra.ext.sql.syntax.MultisetValueExpression" + +-- | A national character string literal, e.g. N'hello' +newtype NationalCharacterStringLiteral = + NationalCharacterStringLiteral { + unNationalCharacterStringLiteral :: ()} + deriving (Eq, Ord, Read, Show) + +_NationalCharacterStringLiteral = Model.Name "hydra.ext.sql.syntax.NationalCharacterStringLiteral" + +-- | A national character string type: NATIONAL CHARACTER or NATIONAL CHARACTER VARYING +newtype NationalCharacterStringType = + NationalCharacterStringType { + unNationalCharacterStringType :: ()} + deriving (Eq, Ord, Read, Show) + +_NationalCharacterStringType = Model.Name "hydra.ext.sql.syntax.NationalCharacterStringType" + +-- | A NEW invocation, constructing an instance of a structured type +newtype NewSpecification = + NewSpecification { + unNewSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_NewSpecification = Model.Name "hydra.ext.sql.syntax.NewSpecification" + +-- | A NEXT VALUE FOR expression, retrieving the next value of a sequence generator +newtype NextValueExpression = + NextValueExpression { + unNextValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_NextValueExpression = Model.Name "hydra.ext.sql.syntax.NextValueExpression" + +-- | A value expression primary that does not begin with a parenthesis +data NonparenthesizedValueExpressionPrimary = + NonparenthesizedValueExpressionPrimaryUnsigned UnsignedValueSpecification | + NonparenthesizedValueExpressionPrimaryColumn ColumnReference | + NonparenthesizedValueExpressionPrimarySetFunction SetFunctionSpecification | + NonparenthesizedValueExpressionPrimaryWindowFunction WindowFunction | + NonparenthesizedValueExpressionPrimaryScalarSubquery ScalarSubquery | + NonparenthesizedValueExpressionPrimaryCases CaseExpression | + NonparenthesizedValueExpressionPrimaryCast CastSpecification | + NonparenthesizedValueExpressionPrimaryField FieldReference | + NonparenthesizedValueExpressionPrimarySubtype SubtypeTreatment | + NonparenthesizedValueExpressionPrimaryMethod MethodInvocation | + NonparenthesizedValueExpressionPrimaryStaticMethod StaticMethodInvocation | + NonparenthesizedValueExpressionPrimaryNew NewSpecification | + NonparenthesizedValueExpressionPrimaryAttributeOrMethod AttributeOrMethodReference | + NonparenthesizedValueExpressionPrimaryReference ReferenceResolution | + NonparenthesizedValueExpressionPrimaryCollection CollectionValueConstructor | + NonparenthesizedValueExpressionPrimaryArrayElement ArrayElementReference | + NonparenthesizedValueExpressionPrimaryMultisetElement MultisetElementReference | + NonparenthesizedValueExpressionPrimaryRoutine RoutineInvocation | + NonparenthesizedValueExpressionPrimaryNext NextValueExpression + deriving (Eq, Ord, Read, Show) + +_NonparenthesizedValueExpressionPrimary = Model.Name "hydra.ext.sql.syntax.NonparenthesizedValueExpressionPrimary" + +_NonparenthesizedValueExpressionPrimary_unsigned = Model.Name "unsigned" + +_NonparenthesizedValueExpressionPrimary_column = Model.Name "column" + +_NonparenthesizedValueExpressionPrimary_setFunction = Model.Name "setFunction" + +_NonparenthesizedValueExpressionPrimary_windowFunction = Model.Name "windowFunction" + +_NonparenthesizedValueExpressionPrimary_scalarSubquery = Model.Name "scalarSubquery" + +_NonparenthesizedValueExpressionPrimary_cases = Model.Name "cases" + +_NonparenthesizedValueExpressionPrimary_cast = Model.Name "cast" + +_NonparenthesizedValueExpressionPrimary_field = Model.Name "field" + +_NonparenthesizedValueExpressionPrimary_subtype = Model.Name "subtype" + +_NonparenthesizedValueExpressionPrimary_method = Model.Name "method" + +_NonparenthesizedValueExpressionPrimary_staticMethod = Model.Name "staticMethod" + +_NonparenthesizedValueExpressionPrimary_new = Model.Name "new" + +_NonparenthesizedValueExpressionPrimary_attributeOrMethod = Model.Name "attributeOrMethod" + +_NonparenthesizedValueExpressionPrimary_reference = Model.Name "reference" + +_NonparenthesizedValueExpressionPrimary_collection = Model.Name "collection" + +_NonparenthesizedValueExpressionPrimary_arrayElement = Model.Name "arrayElement" + +_NonparenthesizedValueExpressionPrimary_multisetElement = Model.Name "multisetElement" + +_NonparenthesizedValueExpressionPrimary_routine = Model.Name "routine" + +_NonparenthesizedValueExpressionPrimary_next = Model.Name "next" + +-- | A numeric type: exact or approximate +data NumericType = + NumericTypeExact ExactNumericType | + NumericTypeApproximate ApproximateNumericType + deriving (Eq, Ord, Read, Show) + +_NumericType = Model.Name "hydra.ext.sql.syntax.NumericType" + +_NumericType_exact = Model.Name "exact" + +_NumericType_approximate = Model.Name "approximate" + +-- | An expression that evaluates to a numeric value +newtype NumericValueExpression = + NumericValueExpression { + unNumericValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_NumericValueExpression = Model.Name "hydra.ext.sql.syntax.NumericValueExpression" + +-- | An OVERRIDING USER VALUE or OVERRIDING SYSTEM VALUE clause of an INSERT statement +data OverrideClause = + OverrideClauseOVERRIDINGspUSERspVALUE | + OverrideClauseOVERRIDINGspSYSTEMspVALUE + deriving (Eq, Ord, Read, Show) + +_OverrideClause = Model.Name "hydra.ext.sql.syntax.OverrideClause" + +_OverrideClause_OVERRIDINGspUSERspVALUE = Model.Name "OVERRIDINGspUSERspVALUE" + +_OverrideClause_OVERRIDINGspSYSTEMspVALUE = Model.Name "OVERRIDINGspSYSTEMspVALUE" + +-- | A value expression enclosed in parentheses +newtype ParenthesizedValueExpression = + ParenthesizedValueExpression { + unParenthesizedValueExpression :: ValueExpression} + deriving (Eq, Ord, Read, Show) + +_ParenthesizedValueExpression = Model.Name "hydra.ext.sql.syntax.ParenthesizedValueExpression" + +-- | A user-defined type name, resolved against the current schema path +newtype PathResolvedUserDefinedTypeName = + PathResolvedUserDefinedTypeName { + unPathResolvedUserDefinedTypeName :: String} + deriving (Eq, Ord, Read, Show) + +_PathResolvedUserDefinedTypeName = Model.Name "hydra.ext.sql.syntax.PathResolvedUserDefinedTypeName" + +-- | The precision of a numeric type, as an unsigned integer +newtype Precision = + Precision { + unPrecision :: UnsignedInteger} + deriving (Eq, Ord, Read, Show) + +_Precision = Model.Name "hydra.ext.sql.syntax.Precision" + +-- | A predefined data type: string, numeric, boolean, datetime, or interval +data PredefinedType = + PredefinedTypeStringType PredefinedTypeString | + PredefinedTypeNationalStringType PredefinedTypeNationalString | + PredefinedTypeBlob BinaryLargeObjectStringType | + PredefinedTypeNumeric NumericType | + PredefinedTypeBoolean BooleanType | + PredefinedTypeDatetime DatetimeType | + PredefinedTypeInterval IntervalType + deriving (Eq, Ord, Read, Show) + +_PredefinedType = Model.Name "hydra.ext.sql.syntax.PredefinedType" + +_PredefinedType_stringType = Model.Name "stringType" + +_PredefinedType_nationalStringType = Model.Name "nationalStringType" + +_PredefinedType_blob = Model.Name "blob" + +_PredefinedType_numeric = Model.Name "numeric" + +_PredefinedType_boolean = Model.Name "boolean" + +_PredefinedType_datetime = Model.Name "datetime" + +_PredefinedType_interval = Model.Name "interval" + +-- | A national character string type together with an optional COLLATE clause +data PredefinedTypeNationalString = + PredefinedTypeNationalString { + predefinedTypeNationalStringType :: NationalCharacterStringType, + predefinedTypeNationalStringCollate :: (Maybe CollateClause)} + deriving (Eq, Ord, Read, Show) + +_PredefinedTypeNationalString = Model.Name "hydra.ext.sql.syntax.PredefinedTypeNationalString" + +_PredefinedTypeNationalString_type = Model.Name "type" + +_PredefinedTypeNationalString_collate = Model.Name "collate" + +-- | A character string type together with an optional character set and COLLATE clause +data PredefinedTypeString = + PredefinedTypeString { + predefinedTypeStringType :: CharacterStringType, + predefinedTypeStringCharacters :: (Maybe CharacterSetSpecification), + predefinedTypeStringCollate :: (Maybe CollateClause)} + deriving (Eq, Ord, Read, Show) + +_PredefinedTypeString = Model.Name "hydra.ext.sql.syntax.PredefinedTypeString" + +_PredefinedTypeString_type = Model.Name "type" + +_PredefinedTypeString_characters = Model.Name "characters" + +_PredefinedTypeString_collate = Model.Name "collate" + +-- | A predicate, evaluating to a boolean truth value +newtype Predicate = + Predicate { + unPredicate :: ()} + deriving (Eq, Ord, Read, Show) + +_Predicate = Model.Name "hydra.ext.sql.syntax.Predicate" + +-- | A query expression, such as a SELECT statement possibly combined with set operators +newtype QueryExpression = + QueryExpression { + unQueryExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_QueryExpression = Model.Name "hydra.ext.sql.syntax.QueryExpression" + +-- | The DEREF operator, resolving a reference to the value it targets +newtype ReferenceResolution = + ReferenceResolution { + unReferenceResolution :: ()} + deriving (Eq, Ord, Read, Show) + +_ReferenceResolution = Model.Name "hydra.ext.sql.syntax.ReferenceResolution" + +-- | A REFERENCES ARE [NOT] CHECKED clause on a reference-typed column +newtype ReferenceScopeCheck = + ReferenceScopeCheck { + unReferenceScopeCheck :: ()} + deriving (Eq, Ord, Read, Show) + +_ReferenceScopeCheck = Model.Name "hydra.ext.sql.syntax.ReferenceScopeCheck" + +-- | A REF reference type over a given referenced type +newtype ReferenceType = + ReferenceType { + unReferenceType :: ()} + deriving (Eq, Ord, Read, Show) + +_ReferenceType = Model.Name "hydra.ext.sql.syntax.ReferenceType" + +-- | An expression that evaluates to a reference value +newtype ReferenceValueExpression = + ReferenceValueExpression { + unReferenceValueExpression :: ValueExpressionPrimary} + deriving (Eq, Ord, Read, Show) + +_ReferenceValueExpression = Model.Name "hydra.ext.sql.syntax.ReferenceValueExpression" + +-- | A right square bracket, or its trigraph equivalent ??) +newtype RightBracketOrTrigraph = + RightBracketOrTrigraph { + unRightBracketOrTrigraph :: String} + deriving (Eq, Ord, Read, Show) + +_RightBracketOrTrigraph = Model.Name "hydra.ext.sql.syntax.RightBracketOrTrigraph" + +-- | An invocation of a user-defined SQL routine +newtype RoutineInvocation = + RoutineInvocation { + unRoutineInvocation :: ()} + deriving (Eq, Ord, Read, Show) + +_RoutineInvocation = Model.Name "hydra.ext.sql.syntax.RoutineInvocation" + +-- | A ROW type, defined by a list of field name and data type pairs +newtype RowType = + RowType { + unRowType :: ()} + deriving (Eq, Ord, Read, Show) + +_RowType = Model.Name "hydra.ext.sql.syntax.RowType" + +-- | An expression that evaluates to a row value +newtype RowValueExpression = + RowValueExpression { + unRowValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_RowValueExpression = Model.Name "hydra.ext.sql.syntax.RowValueExpression" + +-- | A row value expressed as a single nonparenthesized value expression +newtype RowValueSpecialCase = + RowValueSpecialCase { + unRowValueSpecialCase :: NonparenthesizedValueExpressionPrimary} + deriving (Eq, Ord, Read, Show) + +_RowValueSpecialCase = Model.Name "hydra.ext.sql.syntax.RowValueSpecialCase" + +-- | A subquery that returns exactly one row and one column +newtype ScalarSubquery = + ScalarSubquery { + unScalarSubquery :: Subquery} + deriving (Eq, Ord, Read, Show) + +_ScalarSubquery = Model.Name "hydra.ext.sql.syntax.ScalarSubquery" + +-- | The scale of a numeric type, as an unsigned integer +newtype Scale = + Scale { + unScale :: UnsignedInteger} + deriving (Eq, Ord, Read, Show) + +_Scale = Model.Name "hydra.ext.sql.syntax.Scale" + +-- | A REF IS clause identifying a table's self-referencing column +newtype SelfReferencingColumnSpecification = + SelfReferencingColumnSpecification { + unSelfReferencingColumnSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_SelfReferencingColumnSpecification = Model.Name "hydra.ext.sql.syntax.SelfReferencingColumnSpecification" + +-- | A set (aggregate) function invocation, such as COUNT or SUM +newtype SetFunctionSpecification = + SetFunctionSpecification { + unSetFunctionSpecification :: ()} + deriving (Eq, Ord, Read, Show) + +_SetFunctionSpecification = Model.Name "hydra.ext.sql.syntax.SetFunctionSpecification" + +-- | An invocation of a static method on a user-defined type +newtype StaticMethodInvocation = + StaticMethodInvocation { + unStaticMethodInvocation :: ()} + deriving (Eq, Ord, Read, Show) + +_StaticMethodInvocation = Model.Name "hydra.ext.sql.syntax.StaticMethodInvocation" + +-- | An expression that evaluates to a character, binary, or Unicode string value +newtype StringValueExpression = + StringValueExpression { + unStringValueExpression :: ()} + deriving (Eq, Ord, Read, Show) + +_StringValueExpression = Model.Name "hydra.ext.sql.syntax.StringValueExpression" + +-- | A parenthesized query expression used as an operand +newtype Subquery = + Subquery { + unSubquery :: QueryExpression} + deriving (Eq, Ord, Read, Show) + +_Subquery = Model.Name "hydra.ext.sql.syntax.Subquery" + +-- | An UNDER clause declaring a table as a subtable of a supertable +newtype SubtableClause = + SubtableClause { + unSubtableClause :: ()} + deriving (Eq, Ord, Read, Show) + +_SubtableClause = Model.Name "hydra.ext.sql.syntax.SubtableClause" + +-- | A TREAT AS expression, treating a value as an instance of a subtype +newtype SubtypeTreatment = + SubtypeTreatment { + unSubtypeTreatment :: ()} + deriving (Eq, Ord, Read, Show) + +_SubtypeTreatment = Model.Name "hydra.ext.sql.syntax.SubtypeTreatment" + +-- | The ON COMMIT action of a temporary table: PRESERVE ROWS or DELETE ROWS +data TableCommitAction = + TableCommitActionPreserve | + TableCommitActionDelete + deriving (Eq, Ord, Read, Show) + +_TableCommitAction = Model.Name "hydra.ext.sql.syntax.TableCommitAction" + +_TableCommitAction_preserve = Model.Name "preserve" + +_TableCommitAction_delete = Model.Name "delete" + +-- | A table-level constraint definition +newtype TableConstraintDefinition = + TableConstraintDefinition { + unTableConstraintDefinition :: ()} + deriving (Eq, Ord, Read, Show) + +_TableConstraintDefinition = Model.Name "hydra.ext.sql.syntax.TableConstraintDefinition" + +-- | The source of a table's contents: an element list, a supertable, or a query +data TableContentsSource = + TableContentsSourceList TableElementList | + TableContentsSourceSubtableOf TableContentsSourceSubtable | + TableContentsSourceSubquery AsSubqueryClause + deriving (Eq, Ord, Read, Show) + +_TableContentsSource = Model.Name "hydra.ext.sql.syntax.TableContentsSource" + +_TableContentsSource_list = Model.Name "list" + +_TableContentsSource_subtableOf = Model.Name "subtableOf" + +_TableContentsSource_subquery = Model.Name "subquery" + +-- | A table's contents defined as a subtable of a named user-defined type +data TableContentsSourceSubtable = + TableContentsSourceSubtable { + tableContentsSourceSubtableType :: PathResolvedUserDefinedTypeName, + tableContentsSourceSubtableSubtable :: (Maybe SubtableClause), + tableContentsSourceSubtableElements :: (Maybe TableElementList)} + deriving (Eq, Ord, Read, Show) + +_TableContentsSourceSubtable = Model.Name "hydra.ext.sql.syntax.TableContentsSourceSubtable" + +_TableContentsSourceSubtable_type = Model.Name "type" + +_TableContentsSourceSubtable_subtable = Model.Name "subtable" + +_TableContentsSourceSubtable_elements = Model.Name "elements" + +-- | An ANSI SQL CREATE TABLE statement +data TableDefinition = + TableDefinition { + tableDefinitionScope :: (Maybe TableScope), + tableDefinitionName :: TableName, + tableDefinitionSource :: TableContentsSource, + tableDefinitionCommitActions :: (Maybe TableCommitAction)} + deriving (Eq, Ord, Read, Show) + +_TableDefinition = Model.Name "hydra.ext.sql.syntax.TableDefinition" + +_TableDefinition_scope = Model.Name "scope" + +_TableDefinition_name = Model.Name "name" + +_TableDefinition_source = Model.Name "source" + +_TableDefinition_commitActions = Model.Name "commitActions" + +-- | An element of a table definition: a column, constraint, LIKE clause, or related option +data TableElement = + TableElementColumn ColumnDefinition | + TableElementTableConstraint TableConstraintDefinition | + TableElementLike LikeClause | + TableElementSelfReferencingColumn SelfReferencingColumnSpecification | + TableElementColumOptions ColumnOptions + deriving (Eq, Ord, Read, Show) + +_TableElement = Model.Name "hydra.ext.sql.syntax.TableElement" + +_TableElement_column = Model.Name "column" + +_TableElement_tableConstraint = Model.Name "tableConstraint" + +_TableElement_like = Model.Name "like" + +_TableElement_selfReferencingColumn = Model.Name "selfReferencingColumn" + +_TableElement_columOptions = Model.Name "columOptions" + +-- | A non-empty, comma-separated list of table elements +data TableElementList = + TableElementList { + tableElementListFirst :: TableElement, + tableElementListRest :: [TableElement]} + deriving (Eq, Ord, Read, Show) + +_TableElementList = Model.Name "hydra.ext.sql.syntax.TableElementList" + +_TableElementList_first = Model.Name "first" + +_TableElementList_rest = Model.Name "rest" + +-- | The name of a table +newtype TableName = + TableName { + unTableName :: String} + deriving (Eq, Ord, Read, Show) + +_TableName = Model.Name "hydra.ext.sql.syntax.TableName" + +-- | The GLOBAL or LOCAL TEMPORARY scope of a table definition +newtype TableScope = + TableScope { + unTableScope :: GlobalOrLocal} + deriving (Eq, Ord, Read, Show) + +_TableScope = Model.Name "hydra.ext.sql.syntax.TableScope" + +-- | A TIME literal +newtype TimeLiteral = + TimeLiteral { + unTimeLiteral :: TimeString} + deriving (Eq, Ord, Read, Show) + +_TimeLiteral = Model.Name "hydra.ext.sql.syntax.TimeLiteral" + +-- | The string representation of a time literal, e.g. '12:00:00' +newtype TimeString = + TimeString { + unTimeString :: ()} + deriving (Eq, Ord, Read, Show) + +_TimeString = Model.Name "hydra.ext.sql.syntax.TimeString" + +-- | A timestamp literal, combining a date and a time +newtype TimestampLiteral = + TimestampLiteral { + unTimestampLiteral :: ()} + deriving (Eq, Ord, Read, Show) + +_TimestampLiteral = Model.Name "hydra.ext.sql.syntax.TimestampLiteral" + +-- | A three-valued logic truth value: TRUE, FALSE, or UNKNOWN +data TruthValue = + TruthValueTRUE | + TruthValueFALSE | + TruthValueUNKNOWN + deriving (Eq, Ord, Read, Show) + +_TruthValue = Model.Name "hydra.ext.sql.syntax.TruthValue" + +_TruthValue_TRUE = Model.Name "TRUE" + +_TruthValue_FALSE = Model.Name "FALSE" + +_TruthValue_UNKNOWN = Model.Name "UNKNOWN" + +-- | A Unicode character string literal, e.g. U&'hello' +newtype UnicodeCharacterStringLiteral = + UnicodeCharacterStringLiteral { + unUnicodeCharacterStringLiteral :: ()} + deriving (Eq, Ord, Read, Show) + +_UnicodeCharacterStringLiteral = Model.Name "hydra.ext.sql.syntax.UnicodeCharacterStringLiteral" + +-- | An unsigned integer literal +newtype UnsignedInteger = + UnsignedInteger { + unUnsignedInteger :: String} + deriving (Eq, Ord, Read, Show) + +_UnsignedInteger = Model.Name "hydra.ext.sql.syntax.UnsignedInteger" + +-- | An unsigned literal: a numeric or general literal +data UnsignedLiteral = + UnsignedLiteralNumeric UnsignedNumericLiteral | + UnsignedLiteralGeneral GeneralLiteral + deriving (Eq, Ord, Read, Show) + +_UnsignedLiteral = Model.Name "hydra.ext.sql.syntax.UnsignedLiteral" + +_UnsignedLiteral_numeric = Model.Name "numeric" + +_UnsignedLiteral_general = Model.Name "general" + +-- | An unsigned numeric literal: exact or approximate +data UnsignedNumericLiteral = + UnsignedNumericLiteralExact ExactNumericLiteral | + UnsignedNumericLiteralApproximate ApproximateNumericLiteral + deriving (Eq, Ord, Read, Show) + +_UnsignedNumericLiteral = Model.Name "hydra.ext.sql.syntax.UnsignedNumericLiteral" + +_UnsignedNumericLiteral_exact = Model.Name "exact" + +_UnsignedNumericLiteral_approximate = Model.Name "approximate" + +-- | An unsigned value specification: a literal or a general value specification +data UnsignedValueSpecification = + UnsignedValueSpecificationLiteral UnsignedLiteral | + UnsignedValueSpecificationGeneral GeneralValueSpecification + deriving (Eq, Ord, Read, Show) + +_UnsignedValueSpecification = Model.Name "hydra.ext.sql.syntax.UnsignedValueSpecification" + +_UnsignedValueSpecification_literal = Model.Name "literal" + +_UnsignedValueSpecification_general = Model.Name "general" + +-- | An expression that evaluates to a value of a user-defined type +newtype UserDefinedTypeValueExpression = + UserDefinedTypeValueExpression { + unUserDefinedTypeValueExpression :: ValueExpressionPrimary} + deriving (Eq, Ord, Read, Show) + +_UserDefinedTypeValueExpression = Model.Name "hydra.ext.sql.syntax.UserDefinedTypeValueExpression" + +-- | A value expression: common, boolean, or row-valued +data ValueExpression = + ValueExpressionCommon CommonValueExpression | + ValueExpressionBoolean BooleanValueExpression | + ValueExpressionRow RowValueExpression + deriving (Eq, Ord, Read, Show) + +_ValueExpression = Model.Name "hydra.ext.sql.syntax.ValueExpression" + +_ValueExpression_common = Model.Name "common" + +_ValueExpression_boolean = Model.Name "boolean" + +_ValueExpression_row = Model.Name "row" + +-- | A value expression primary, optionally parenthesized +data ValueExpressionPrimary = + ValueExpressionPrimaryParens ParenthesizedValueExpression | + ValueExpressionPrimaryNoparens NonparenthesizedValueExpressionPrimary + deriving (Eq, Ord, Read, Show) + +_ValueExpressionPrimary = Model.Name "hydra.ext.sql.syntax.ValueExpressionPrimary" + +_ValueExpressionPrimary_parens = Model.Name "parens" + +_ValueExpressionPrimary_noparens = Model.Name "noparens" + +-- | A window function invocation, such as ROW_NUMBER() OVER (...) +newtype WindowFunction = + WindowFunction { + unWindowFunction :: ()} + deriving (Eq, Ord, Read, Show) + +_WindowFunction = Model.Name "hydra.ext.sql.syntax.WindowFunction" diff --git a/src/main/haskell/Hydra/Ext/Stac/Items.hs b/src/main/haskell/Hydra/Ext/Stac/Items.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Stac/Items.hs @@ -0,0 +1,191 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for SpatioTemporal Asset Catalog (STAC) Items. See https://github.com/radiantearth/stac-spec/blob/master/item-spec/item-spec.md + +module Hydra.Ext.Stac.Items where + +import qualified Hydra.Core.Model as Model +import qualified Hydra.Ext.Geojson.Model as GeojsonModel +import qualified Hydra.Ext.Iana.Linkrelations as Linkrelations +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | An Asset is an object that contains a URI to data associated with the Item that can be downloaded or streamed. It is allowed to add additional fields. +data Asset = + Asset { + -- | URI to the asset object. Relative and absolute URI are both allowed. + assetHref :: Uri, + -- | The displayed title for clients and users. + assetTitle :: (Maybe String), + -- | A description of the Asset providing additional details, such as how it was processed or created. CommonMark 0.29 syntax MAY be used for rich text representation. + assetDescription :: (Maybe String), + -- | Media type of the asset. See the common media types in the best practice doc for commonly used asset types. + assetType :: (Maybe MediaType), + -- | The semantic roles of the asset, similar to the use of rel in links. + assetRoles :: [Role]} + deriving (Eq, Ord, Read, Show) + +_Asset = Model.Name "hydra.ext.stac.items.Asset" + +_Asset_href = Model.Name "href" + +_Asset_title = Model.Name "title" + +_Asset_description = Model.Name "description" + +_Asset_type = Model.Name "type" + +_Asset_roles = Model.Name "roles" + +-- | This object describes a STAC Item. The fields id, type, bbox, geometry and properties are inherited from GeoJSON. +data Item = + Item { + itemFeature :: GeojsonModel.Feature, + -- | The STAC version the Item implements + itemStacVersion :: StacVersion, + -- | A list of extensions the Item implements + itemStacExtensions :: [Url], + -- | List of link objects to resources and related URLs. A link with the rel set to self is strongly recommended. + itemLinks :: [Link], + -- | Dictionary of asset objects that can be downloaded, each with a unique key. + itemAssets :: (M.Map String Asset), + -- | The id of the STAC Collection this Item references to (see collection relation type). This field is required if such a relation type is present and is not allowed otherwise. This field provides an easy way for a user to search for any Items that belong in a specified Collection. Must be a non-empty string. + itemCollection :: (Maybe GeojsonModel.Id)} + deriving (Eq, Ord, Read, Show) + +_Item = Model.Name "hydra.ext.stac.items.Item" + +_Item_feature = Model.Name "feature" + +_Item_stacVersion = Model.Name "stacVersion" + +_Item_stacExtensions = Model.Name "stacExtensions" + +_Item_links = Model.Name "links" + +_Item_assets = Model.Name "assets" + +_Item_collection = Model.Name "collection" + +-- | This object describes a relationship with another entity. Data providers are advised to be liberal with the links section, to describe things like the Catalog an Item is in, related Items, parent or child Items (modeled in different ways, like an 'acquisition' or derived data). It is allowed to add additional fields such as a title and type. +data Link = + Link { + -- | The actual link in the format of an URL. Relative and absolute links are both allowed. + linkHref :: Url, + -- | Relationship between the current document and the linked document. See chapter "Relation types" for more information. + linkRel :: RelationType, + -- | Media type of the referenced entity. + linkType :: (Maybe MediaType), + -- | A human readable title to be used in rendered displays of the link. + linkTitle :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_Link = Model.Name "hydra.ext.stac.items.Link" + +_Link_href = Model.Name "href" + +_Link_rel = Model.Name "rel" + +_Link_type = Model.Name "type" + +_Link_title = Model.Name "title" + +-- | An IANA media type (MIME type) string identifying the format of an asset or linked resource +newtype MediaType = + MediaType { + unMediaType :: String} + deriving (Eq, Ord, Read, Show) + +_MediaType = Model.Name "hydra.ext.stac.items.MediaType" + +-- | STAC Items use a variety of rel types in the link object, to describe the exact nature of the link between this Item and the entity it is linking to. It is recommended to use the official IANA Link Relation Types where possible. The following table explains places where STAC use custom rel types are used with Items. This happens where there is not a clear official option, or where STAC uses an official type but adds additional meaning for the STAC context. +data RelationType = + RelationTypeIana Linkrelations.LinkRelationType | + RelationTypeStac StacRelationType | + RelationTypeOther String + deriving (Eq, Ord, Read, Show) + +_RelationType = Model.Name "hydra.ext.stac.items.RelationType" + +_RelationType_iana = Model.Name "iana" + +_RelationType_stac = Model.Name "stac" + +_RelationType_other = Model.Name "other" + +-- | The roles field is used to describe the purpose of each asset. It is recommended to include one for every asset, to give users a sense of why they might want to make use of the asset. There are some emerging standards that enable clients to take particular action when they encounter particular roles, listed below. But implementors are encouraged to come up with their own terms to describe the role. +data Role = + -- | An asset that represents a thumbnail of the Item, typically a true color image (for Items with assets in the visible wavelengths), lower-resolution (typically smaller 600x600 pixels), and typically a JPEG or PNG (suitable for display in a web browser). Multiple assets may have this purpose, but it recommended that the type and roles be unique tuples. For example, Sentinel-2 L2A provides thumbnail images in both JPEG and JPEG2000 formats, and would be distinguished by their media types. + RoleThumbnail | + -- | An asset that represents a possibly larger view than the thumbnail of the Item, for example, a true color composite of multi-band data. + RoleOverview | + -- | The data itself. This is a suggestion for a common role for data files to be used in case data providers don't come up with their own names and semantics. + RoleData | + -- | A metadata sidecar file describing the data in this Item, for example the Landsat-8 MTL file. + RoleMetadata | + RoleOther String + deriving (Eq, Ord, Read, Show) + +_Role = Model.Name "hydra.ext.stac.items.Role" + +_Role_thumbnail = Model.Name "thumbnail" + +_Role_overview = Model.Name "overview" + +_Role_data = Model.Name "data" + +_Role_metadata = Model.Name "metadata" + +_Role_other = Model.Name "other" + +-- | A STAC-specific link relation type used to describe relationships between STAC entities +data StacRelationType = + -- | STRONGLY RECOMMENDED. Absolute URL to the Item if it is available at a public URL. This is particularly useful when in a download package that includes metadata, so that the downstream user can know where the data has come from. + StacRelationTypeSelf | + -- | URL to the root STAC entity (Catalog or Collection). + StacRelationTypeRoot | + -- | URL to the parent STAC entity (Catalog or Collection). + StacRelationTypeParent | + -- | STRONGLY RECOMMENDED. URL to a Collection. Absolute URLs should be used whenever possible. The referenced Collection is STRONGLY RECOMMENDED to implement the same STAC version as the Item. A link with this rel type is required if the collection field in properties is present. + StacRelationTypeCollection | + -- | URL to a STAC Item that was used as input data in the creation of this Item. + StacRelationTypeDerivedFrom + deriving (Eq, Ord, Read, Show) + +_StacRelationType = Model.Name "hydra.ext.stac.items.StacRelationType" + +_StacRelationType_self = Model.Name "self" + +_StacRelationType_root = Model.Name "root" + +_StacRelationType_parent = Model.Name "parent" + +_StacRelationType_collection = Model.Name "collection" + +_StacRelationType_derivedFrom = Model.Name "derivedFrom" + +-- | The version of the STAC specification that an Item implements +newtype StacVersion = + StacVersion { + unStacVersion :: String} + deriving (Eq, Ord, Read, Show) + +_StacVersion = Model.Name "hydra.ext.stac.items.StacVersion" + +-- | A URI string, used for asset and other resource references +newtype Uri = + Uri { + unUri :: String} + deriving (Eq, Ord, Read, Show) + +_Uri = Model.Name "hydra.ext.stac.items.Uri" + +-- | A URL string, used for links to related entities +newtype Url = + Url { + unUrl :: String} + deriving (Eq, Ord, Read, Show) + +_Url = Model.Name "hydra.ext.stac.items.Url" diff --git a/src/main/haskell/Hydra/Ext/Workflow.hs b/src/main/haskell/Hydra/Ext/Workflow.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Workflow.hs @@ -0,0 +1,68 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A model for Hydra transformation workflows + +module Hydra.Ext.Workflow where + +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | The specification of a Hydra schema, provided as a set of modules and a distinguished type +data HydraSchemaSpec = + HydraSchemaSpec { + -- | The modules to include in the schema graph + hydraSchemaSpecModules :: [Packaging.Module], + -- | The name of the top-level type; all data which passes through the workflow will be instances of this type + hydraSchemaSpecTypeName :: Model.Name} + deriving (Eq, Ord, Read, Show) + +_HydraSchemaSpec = Model.Name "hydra.ext.workflow.HydraSchemaSpec" + +_HydraSchemaSpec_modules = Model.Name "modules" + +_HydraSchemaSpec_typeName = Model.Name "typeName" + +-- | The specification of a schema at the source end of a workflow +data SchemaSpec = + -- | A native Hydra schema + SchemaSpecHydra HydraSchemaSpec | + -- | A schema provided as a file, available at the given file path + SchemaSpecFile String | + -- | A schema which will be provided within the workflow + SchemaSpecProvided + deriving (Eq, Ord, Read, Show) + +_SchemaSpec = Model.Name "hydra.ext.workflow.SchemaSpec" + +_SchemaSpec_hydra = Model.Name "hydra" + +_SchemaSpec_file = Model.Name "file" + +_SchemaSpec_provided = Model.Name "provided" + +-- | The specification of a workflow which takes a schema specification, reads data from a directory, and writes data to another directory +data TransformWorkflow = + TransformWorkflow { + -- | A descriptive name for the workflow + transformWorkflowName :: String, + -- | The schema specification + transformWorkflowSchemaSpec :: SchemaSpec, + -- | The source directory + transformWorkflowSrcDir :: String, + -- | The destination directory + transformWorkflowDestDir :: String} + deriving (Eq, Ord, Read, Show) + +_TransformWorkflow = Model.Name "hydra.ext.workflow.TransformWorkflow" + +_TransformWorkflow_name = Model.Name "name" + +_TransformWorkflow_schemaSpec = Model.Name "schemaSpec" + +_TransformWorkflow_srcDir = Model.Name "srcDir" + +_TransformWorkflow_destDir = Model.Name "destDir" diff --git a/src/main/haskell/Hydra/Ext/Yaml/Coder.hs b/src/main/haskell/Hydra/Ext/Yaml/Coder.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Yaml/Coder.hs @@ -0,0 +1,281 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | YAML encoding and decoding for Hydra terms + +module Hydra.Ext.Yaml.Coder where + +import qualified Hydra.Core.Adapt as Adapt +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as LibLiterals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Literals as Literals +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Print.Model as PrintModel +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Core.Yaml.Model as YamlModel +import qualified Hydra.Ext.Yaml.Language as Language +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Decode a YAML value to a record term +decodeRecord :: Model.Name -> [(Model.FieldType, (Coders.Coder Model.Term YamlModel.Node Errors.Error))] -> YamlModel.Node -> Either Errors.Error Model.Term +decodeRecord tname coders n = + + let decodeObjectBody = + \m -> + let decodeField = + \coder -> + let ft = Pairs.first coder + coder_ = Pairs.second coder + fname = Model.fieldTypeName ft + defaultValue = YamlModel.NodeScalar YamlModel.ScalarNull + yamlValue = Optionals.withDefault defaultValue (Maps.lookup (YamlModel.NodeScalar (YamlModel.ScalarStr (Model.unName fname))) m) + in (Eithers.bind (Coders.coderDecode coder_ yamlValue) (\v -> Right (Model.Field { + Model.fieldName = fname, + Model.fieldTerm = v}))) + in (Eithers.bind (Eithers.mapList decodeField coders) (\fields -> Right (Model.TermRecord (Model.Record { + Model.recordTypeName = tname, + Model.recordFields = fields})))) + in case n of + YamlModel.NodeMapping v0 -> decodeObjectBody v0 + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected mapping")) + +-- | Encode a record term to YAML +encodeRecord :: [(Model.FieldType, (Coders.Coder Model.Term YamlModel.Node Errors.Error))] -> Graph.Graph -> Model.Term -> Either Errors.Error YamlModel.Node +encodeRecord coders graph term = + + let stripped = Strip.deannotateTerm term + isMaybeNothing = + \ft -> \fvalue -> case (Model.fieldTypeType ft) of + Model.TypeOptional _ -> case fvalue of + Model.TermOptional v1 -> Optionals.isNone v1 + _ -> False + _ -> False + encodeField = + \coderAndField -> + let ftAndCoder = Pairs.first coderAndField + field = Pairs.second coderAndField + ft = Pairs.first ftAndCoder + coder_ = Pairs.second ftAndCoder + fname = Model.fieldName field + fvalue = Model.fieldTerm field + in (Logic.ifElse (isMaybeNothing ft fvalue) (Right Nothing) (Eithers.bind (Coders.coderEncode coder_ fvalue) (\encoded -> Right (Just (YamlModel.NodeScalar (YamlModel.ScalarStr (Model.unName fname)), encoded))))) + in (Eithers.bind (ExtractModel.termRecord graph stripped) (\record -> + let fields = Model.recordFields record + in (Eithers.bind (Eithers.mapList encodeField (Lists.zip coders fields)) (\maybeFields -> Right (YamlModel.NodeMapping (Maps.fromList (Optionals.givens maybeFields))))))) + +-- | Create a YAML coder for literal types +literalYamlCoder :: Model.LiteralType -> Either t0 (Coders.Coder Model.Literal YamlModel.Scalar Errors.Error) +literalYamlCoder lt = + + let decodeBool = + \s -> case s of + YamlModel.ScalarBool v0 -> Right (Model.LiteralBoolean v0) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected boolean, found scalar"]))) + decodeDecimal = + \s -> case s of + YamlModel.ScalarDecimal v0 -> Right (Model.LiteralDecimal v0) + YamlModel.ScalarFloat v0 -> Right (Model.LiteralDecimal (LibLiterals.float64ToDecimal v0)) + YamlModel.ScalarInt v0 -> Right (Model.LiteralDecimal (LibLiterals.bigintToDecimal v0)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected decimal, found scalar"]))) + decodeFloat = + \s -> case s of + YamlModel.ScalarDecimal v0 -> Right (Model.LiteralFloat (Model.FloatValueFloat64 (LibLiterals.decimalToFloat64 v0))) + YamlModel.ScalarFloat v0 -> Right (Model.LiteralFloat (Model.FloatValueFloat64 v0)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected float, found scalar"]))) + decodeInteger = + \s -> case s of + YamlModel.ScalarInt v0 -> Right (Model.LiteralInteger (Model.IntegerValueBigint v0)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected integer, found scalar"]))) + decodeString = + \s -> case s of + YamlModel.ScalarStr v0 -> Right (Model.LiteralString v0) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected string, found scalar"]))) + encoded = + case lt of + Model.LiteralTypeBoolean -> Coders.Coder { + Coders.coderEncode = (\lit -> Eithers.bind (ExtractModel.booleanLiteral lit) (\b -> Right (YamlModel.ScalarBool b))), + Coders.coderDecode = decodeBool} + Model.LiteralTypeDecimal -> Coders.Coder { + Coders.coderEncode = (\lit -> Eithers.bind (ExtractModel.decimalLiteral lit) (\d -> Right (YamlModel.ScalarDecimal d))), + Coders.coderDecode = decodeDecimal} + Model.LiteralTypeFloat _ -> Coders.Coder { + Coders.coderEncode = (\lit -> Eithers.bind (ExtractModel.floatLiteral lit) (\f -> + let bf = + case f of + Model.FloatValueFloat32 v1 -> LibLiterals.float32ToFloat64 v1 + Model.FloatValueFloat64 v1 -> v1 + shown = LibLiterals.printFloat64 bf + in (Logic.ifElse (requiresYamlStringSentinel shown) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "YAML cannot represent float value: ", + shown])))) (Right (YamlModel.ScalarFloat bf))))), + Coders.coderDecode = decodeFloat} + Model.LiteralTypeInteger _ -> Coders.Coder { + Coders.coderEncode = (\lit -> Eithers.bind (ExtractModel.integerLiteral lit) (\i -> Eithers.bind (ExtractModel.bigintValue i) (\bi -> Right (YamlModel.ScalarInt bi)))), + Coders.coderDecode = decodeInteger} + Model.LiteralTypeString -> Coders.Coder { + Coders.coderEncode = (\lit -> Eithers.bind (ExtractModel.stringLiteral lit) (\s -> Right (YamlModel.ScalarStr s))), + Coders.coderDecode = decodeString} + in (Right encoded) + +-- | Create a YAML coder for record types +recordCoder :: Model.Name -> [Model.FieldType] -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Model.Term YamlModel.Node Errors.Error) +recordCoder tname rt cx g = + + let getCoder = \f -> Eithers.bind (termCoder (Model.fieldTypeType f) cx g) (\coder -> Right (f, coder)) + in (Eithers.bind (Eithers.mapList getCoder rt) (\coders -> Right (Coders.Coder { + Coders.coderEncode = (\term -> encodeRecord coders g term), + Coders.coderDecode = (\val -> decodeRecord tname coders val)}))) + +-- | True for IEEE sentinel strings that Hydra YAML cannot represent as a float scalar. +requiresYamlStringSentinel :: String -> Bool +requiresYamlStringSentinel s = + Logic.or (Equality.equal s "NaN") (Logic.or (Equality.equal s "Infinity") (Logic.or (Equality.equal s "-Infinity") (Equality.equal s "-0.0"))) + +-- | Create a YAML coder for term types +termCoder :: Model.Type -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Model.Term YamlModel.Node Errors.Error) +termCoder typ cx g = + + let stripped = Strip.deannotateType typ + encodeLiteral = + \ac -> \term -> case term of + Model.TermLiteral v0 -> Eithers.bind (Coders.coderEncode ac v0) (\scalar -> Right (YamlModel.NodeScalar scalar)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected literal term, found: ", + (PrintModel.term term)]))) + encodeList = + \lc -> \term -> case term of + Model.TermList v0 -> Eithers.bind (Eithers.mapList (\el -> Coders.coderEncode lc el) v0) (\encodedEls -> Right (YamlModel.NodeSequence encodedEls)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected list term, found: ", + (PrintModel.term term)]))) + decodeList = + \lc -> \n -> case n of + YamlModel.NodeSequence v0 -> Eithers.bind (Eithers.mapList (\node -> Coders.coderDecode lc node) v0) (\decodedNodes -> Right (Model.TermList decodedNodes)) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected sequence")) + encodeMaybe = + \maybeElementCoder -> \maybeTerm -> + let strippedMaybeTerm = Strip.deannotateTerm maybeTerm + in case strippedMaybeTerm of + Model.TermOptional v0 -> Optionals.match v0 (Right (YamlModel.NodeScalar YamlModel.ScalarNull)) (\innerTerm -> Eithers.bind (Coders.coderEncode maybeElementCoder innerTerm) (\encodedInner -> Right encodedInner)) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected optional term, found: ", + (PrintModel.term maybeTerm)]))) + decodeMaybe = + \maybeElementCoder -> \yamlVal -> case yamlVal of + YamlModel.NodeScalar v0 -> case v0 of + YamlModel.ScalarNull -> Right (Model.TermOptional Nothing) + _ -> Eithers.bind (Coders.coderDecode maybeElementCoder yamlVal) (\decodedInner -> Right (Model.TermOptional (Just decodedInner))) + _ -> Eithers.bind (Coders.coderDecode maybeElementCoder yamlVal) (\decodedInner -> Right (Model.TermOptional (Just decodedInner))) + result = + case stripped of + Model.TypeLiteral v0 -> Eithers.bind (literalYamlCoder v0) (\ac -> Right (Coders.Coder { + Coders.coderEncode = (encodeLiteral ac), + Coders.coderDecode = (\n -> case n of + YamlModel.NodeScalar v1 -> Eithers.bind (Coders.coderDecode ac v1) (\lit -> Right (Model.TermLiteral lit)) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected scalar node")))})) + Model.TypeList v0 -> Eithers.bind (termCoder v0 cx g) (\lc -> Right (Coders.Coder { + Coders.coderEncode = (encodeList lc), + Coders.coderDecode = (decodeList lc)})) + Model.TypeMap v0 -> + let kt = Model.mapTypeKeys v0 + vt = Model.mapTypeValues v0 + in (Eithers.bind (termCoder kt cx g) (\kc -> Eithers.bind (termCoder vt cx g) (\vc -> + let encodeEntry = + \kv -> + let k = Pairs.first kv + v = Pairs.second kv + in (Eithers.bind (Coders.coderEncode kc k) (\encodedK -> Eithers.bind (Coders.coderEncode vc v) (\encodedV -> Right (encodedK, encodedV)))) + decodeEntry = + \kv -> + let k = Pairs.first kv + v = Pairs.second kv + in (Eithers.bind (Coders.coderDecode kc k) (\decodedK -> Eithers.bind (Coders.coderDecode vc v) (\decodedV -> Right (decodedK, decodedV)))) + in (Right (Coders.Coder { + Coders.coderEncode = (\term -> case term of + Model.TermMap v1 -> Eithers.bind (Eithers.mapList (\entry -> encodeEntry entry) (Maps.toList v1)) (\entries -> Right (YamlModel.NodeMapping (Maps.fromList entries))) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected map term, found: ", + (PrintModel.term term)])))), + Coders.coderDecode = (\n -> case n of + YamlModel.NodeMapping v1 -> Eithers.bind (Eithers.mapList (\entry -> decodeEntry entry) (Maps.toList v1)) (\entries -> Right (Model.TermMap (Maps.fromList entries))) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected mapping")))}))))) + Model.TypeOptional v0 -> Eithers.bind (termCoder v0 cx g) (\maybeElementCoder -> Right (Coders.Coder { + Coders.coderEncode = (encodeMaybe maybeElementCoder), + Coders.coderDecode = (decodeMaybe maybeElementCoder)})) + Model.TypeRecord v0 -> recordCoder (Model.Name "yaml") v0 cx g + Model.TypeUnit -> Right unitCoder + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "unsupported type in YAML: ", + (PrintModel.type_ typ)]))) + in result + +-- | YAML coder for unit values +unitCoder :: Coders.Coder Model.Term YamlModel.Node Errors.Error +unitCoder = + Coders.Coder { + Coders.coderEncode = encodeUnit, + Coders.coderDecode = decodeUnit} + where + encodeUnit = + \term -> case (Strip.deannotateTerm term) of + Model.TermUnit -> Right (YamlModel.NodeScalar YamlModel.ScalarNull) + _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ + "expected unit, found: ", + (PrintModel.term term)]))) + decodeUnit = + \n -> case n of + YamlModel.NodeScalar v0 -> case v0 of + YamlModel.ScalarNull -> Right Model.TermUnit + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected null scalar")) + _ -> Left (Errors.ErrorOther (Errors.OtherError "expected null")) + +-- | Create a YAML coder for a given type +yamlCoder :: Model.Type -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Model.Term YamlModel.Node Errors.Error) +yamlCoder typ cx g = + + let mkTermCoder = \t -> termCoder t cx g + in (Eithers.bind (Adapt.simpleLanguageAdapter Language.yamlLanguage cx g typ) (\adapter -> Eithers.bind (mkTermCoder (Coders.adapterTarget adapter)) (\coder -> Right (Adapt.composeCoders (Coders.adapterCoder adapter) coder)))) diff --git a/src/main/haskell/Hydra/Ext/Yaml/Language.hs b/src/main/haskell/Hydra/Ext/Yaml/Language.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Yaml/Language.hs @@ -0,0 +1,105 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Language constraints for YAML + +module Hydra.Ext.Yaml.Language where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Language constraints for YAML +yamlLanguage :: Coders.Language +yamlLanguage = + Coders.Language { + Coders.languageName = (Coders.LanguageName "hydra.yaml"), + Coders.languageConstraints = Coders.LanguageConstraints { + Coders.languageConstraintsLiteralVariants = literalVariants, + Coders.languageConstraintsFloatTypes = floatTypes, + Coders.languageConstraintsIntegerTypes = integerTypes, + Coders.languageConstraintsTermVariants = termVariants, + Coders.languageConstraintsTypeVariants = typeVariants, + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "yaml")} + where + literalVariants = + Sets.fromList [ + Variants.LiteralVariantBoolean, + Variants.LiteralVariantFloat, + Variants.LiteralVariantInteger, + Variants.LiteralVariantString] + floatTypes = Sets.fromList [ + Model.FloatTypeFloat64] + integerTypes = Sets.fromList [ + Model.IntegerTypeBigint] + termVariants = + Sets.fromList [ + Variants.TermVariantLiteral, + Variants.TermVariantList, + Variants.TermVariantMap, + Variants.TermVariantOptional, + Variants.TermVariantRecord, + Variants.TermVariantUnit] + typeVariants = + Sets.fromList [ + Variants.TypeVariantLiteral, + Variants.TypeVariantList, + Variants.TypeVariantMap, + Variants.TypeVariantOptional, + Variants.TypeVariantRecord, + Variants.TypeVariantUnit, + Variants.TypeVariantVoid] + typePredicate = + \typ -> case (Strip.deannotateType typ) of + Model.TypeOptional v0 -> case v0 of + Model.TypeOptional _ -> False + _ -> True + _ -> True diff --git a/src/main/haskell/Hydra/Ext/Yaml/Serde.hs b/src/main/haskell/Hydra/Ext/Yaml/Serde.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ext/Yaml/Serde.hs @@ -0,0 +1,266 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Native YAML serialization: YAML Node to String + +module Hydra.Ext.Yaml.Serde where + +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Formatting as Formatting +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Chars as Chars +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants +import qualified Hydra.Core.Yaml.Model as YamlModel +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Escape single quotes by doubling them +escapeSingleQuotes :: String -> String +escapeSingleQuotes s = + + let squote = 39 + in (Strings.fromList (Lists.bind (Strings.toList s) (\c -> Logic.ifElse (Equality.equal c squote) [ + squote, + squote] [ + c]))) + +-- | Check if a string has leading or trailing whitespace +hasLeadingTrailingSpace :: String -> Bool +hasLeadingTrailingSpace s = + + let chars = Strings.toList s + in (Logic.or (Optionals.withDefault False (Optionals.map (\c -> Chars.isSpace c) (Lists.head chars))) (Optionals.withDefault False (Optionals.map (\c -> Chars.isSpace c) (Lists.last chars)))) + +-- | Serialize a YAML node to a string +hydraYamlToString :: YamlModel.Node -> String +hydraYamlToString node = writeNode node + +-- | Indent all lines of a string by 2 spaces +indentString :: String -> String +indentString s = + Strings.concat (Lists.map (\line -> Logic.ifElse (Strings.isEmpty line) "" (Strings.concat [ + " ", + line, + "\n"])) (Formatting.lines s)) + +-- | Check if character codes represent a decimal number +isDecimalString :: [Int] -> Bool +isDecimalString chars = + + let dotCode = 46 + parts = Lists.span (\c -> Logic.not (Equality.equal c dotCode)) chars + before = Pairs.first parts + afterWithDot = Pairs.second parts + in (Logic.ifElse (Lists.isEmpty before) False (Logic.ifElse (Lists.isEmpty afterWithDot) False ( + let after = Lists.drop 1 afterWithDot + in (Logic.ifElse (Lists.isEmpty after) False ( + let isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) + in (Logic.and (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) before)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) after)))))))) + +-- | Check if a string looks like a number +looksLikeNumber :: String -> Bool +looksLikeNumber s = + + let chars = Strings.toList s + in (Optionals.withDefault False (Optionals.map (\p -> + let firstCh = Pairs.first p + tailCh = Pairs.second p + rest = Logic.ifElse (Equality.equal firstCh 45) tailCh chars + isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) + allDigits = Logic.and (Logic.not (Lists.isEmpty rest)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) rest)) + in (Logic.ifElse allDigits True (isDecimalString rest))) (Lists.uncons chars))) + +-- | Check if a string needs quoting in YAML +needsQuoting :: String -> Bool +needsQuoting s = + Logic.ifElse (Strings.isEmpty s) True (Logic.ifElse (Lists.member s yamlReservedWords) True (Logic.ifElse (looksLikeNumber s) True ( + let chars = Strings.toList s + specials = Strings.toList yamlSpecialChars + hasSpecial = Logic.not (Lists.isEmpty (Lists.filter (\c -> Lists.member c specials) chars)) + in (Logic.ifElse hasSpecial True (hasLeadingTrailingSpace s))))) + +-- | Write a mapping entry in block style +writeMappingEntry :: (YamlModel.Node, YamlModel.Node) -> String +writeMappingEntry entry = + + let key = Pairs.first entry + value = Pairs.second entry + in case value of + YamlModel.NodeScalar v0 -> Strings.concat [ + writeNodeInline key, + ": ", + (writeScalar v0), + "\n"] + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ + writeNodeInline key, + ": []\n"]) (Strings.concat [ + writeNodeInline key, + ":\n", + (indentString (writeNode value))]) + YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) (Strings.concat [ + writeNodeInline key, + ": {}\n"]) (Strings.concat [ + writeNodeInline key, + ":\n", + (indentString (writeNode value))]) + +-- | Write a mapping entry for the first item of a sequence element +writeMappingEntryInline :: (YamlModel.Node, YamlModel.Node) -> String +writeMappingEntryInline entry = + + let key = Pairs.first entry + value = Pairs.second entry + in case value of + YamlModel.NodeScalar v0 -> Strings.concat [ + writeNodeInline key, + ": ", + (writeScalar v0), + "\n"] + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ + writeNodeInline key, + ": []\n"]) (Strings.concat [ + writeNodeInline key, + ":\n", + (indentString (writeNode value))]) + YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) (Strings.concat [ + writeNodeInline key, + ": {}\n"]) (Strings.concat [ + writeNodeInline key, + ":\n", + (indentString (writeNode value))]) + +-- | Write a YAML node as a top-level value in block style +writeNode :: YamlModel.Node -> String +writeNode node = + case node of + YamlModel.NodeScalar v0 -> Strings.concat2 (writeScalar v0) "\n" + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "[]\n" (Strings.concat (Lists.map (\item -> writeSequenceItem item) v0)) + YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "{}\n" (Strings.concat (Lists.map (\e -> writeMappingEntry e) (Maps.toList v0))) + +-- | Write a node inline (for use as a mapping key) +writeNodeInline :: YamlModel.Node -> String +writeNodeInline node = + case node of + YamlModel.NodeScalar v0 -> writeScalar v0 + YamlModel.NodeSequence v0 -> Strings.concat [ + "[", + (Strings.join ", " (Lists.map (\item -> writeNodeInline item) v0)), + "]"] + YamlModel.NodeMapping v0 -> + let writeFlowEntry = + \e -> Strings.concat [ + writeNodeInline (Pairs.first e), + ": ", + (writeNodeInline (Pairs.second e))] + in (Strings.concat [ + "{", + (Strings.join ", " (Lists.map writeFlowEntry (Maps.toList v0))), + "}"]) + +-- | Write a scalar value +writeScalar :: YamlModel.Scalar -> String +writeScalar s = + case s of + YamlModel.ScalarBool v0 -> Logic.ifElse v0 "true" "false" + YamlModel.ScalarDecimal v0 -> Literals.printDecimal v0 + YamlModel.ScalarFloat v0 -> Literals.printFloat64 v0 + YamlModel.ScalarInt v0 -> Literals.printBigint v0 + YamlModel.ScalarNull -> "null" + YamlModel.ScalarStr v0 -> writeString v0 + +-- | Write a sequence item in block style +writeSequenceItem :: YamlModel.Node -> String +writeSequenceItem node = + case node of + YamlModel.NodeScalar v0 -> Strings.concat [ + "- ", + (writeScalar v0), + "\n"] + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "- []\n" (Strings.concat2 "-\n" (indentString (writeNode node))) + YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "- {}\n" ( + let entries = Maps.toList v0 + in (Optionals.withDefault "" (Optionals.map (\p -> + let firstEntry = Pairs.first p + restEntries = Pairs.second p + firstStr = writeMappingEntryInline firstEntry + restStr = Strings.concat (Lists.map (\e -> writeMappingEntry e) restEntries) + in (Strings.concat [ + "- ", + firstStr, + (indentString restStr)])) (Lists.uncons entries)))) + +-- | Write a string value, quoting if necessary +writeString :: String -> String +writeString s = + Logic.ifElse (needsQuoting s) (Strings.concat [ + "'", + (escapeSingleQuotes s), + "'"]) s + +-- | YAML reserved words that need quoting +yamlReservedWords :: [String] +yamlReservedWords = + [ + "true", + "false", + "null", + "~", + "yes", + "no", + "on", + "off", + "True", + "False", + "Null", + "Yes", + "No", + "On", + "Off", + "TRUE", + "FALSE", + "NULL", + "YES", + "NO", + "ON", + "OFF"] + +-- | YAML special characters that trigger quoting +yamlSpecialChars :: String +yamlSpecialChars = ": {}[]#,&*!|>'\"%@`" diff --git a/src/main/haskell/Hydra/Geojson/Model.hs b/src/main/haskell/Hydra/Geojson/Model.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Geojson/Model.hs +++ /dev/null @@ -1,230 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A GeoJSON model based on the specification at https://www.rfc-editor.org/rfc/rfc7946. This model provides some additional structure beyond the JSON encoding described in the specification; For example, it provides MultiPoint not as an object with an array of coordinates which encode points, but as an array of Points. A BoundingBox is not simply an list of numbers, but a list of CoordinateRanges. - -module Hydra.Geojson.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | A GeoJSON object MAY have a member named "bbox" to include information on the coordinate range for its Geometries, Features, or FeatureCollections. The value of the bbox member MUST be an array of length 2*n where n is the number of dimensions represented in the contained geometries, with all axes of the most southwesterly point followed by all axes of the more northeasterly point. The axes order of a bbox follows the axes order of geometries. -newtype BoundingBox = - BoundingBox { - unBoundingBox :: [CoordinateRange]} - deriving (Eq, Ord, Read, Show) - -_BoundingBox = Core.Name "hydra.geojson.model.BoundingBox" - --- | The minimum and maximum values along one axis of a bounding box -data CoordinateRange = - CoordinateRange { - coordinateRangeMin :: Double, - coordinateRangeMax :: Double} - deriving (Eq, Ord, Read, Show) - -_CoordinateRange = Core.Name "hydra.geojson.model.CoordinateRange" - -_CoordinateRange_min = Core.Name "min" - -_CoordinateRange_max = Core.Name "max" - --- | A Feature object represents a spatially bounded thing. Every Feature object is a GeoJSON object no matter where it occurs in a GeoJSON text. -data Feature = - Feature { - -- | A Feature object has a member with the name "geometry". The value of the geometry member SHALL be either a Geometry object as defined above or, in the case that the Feature is unlocated, a JSON null value. - featureGeometry :: (Maybe Geometry), - -- | A Feature object has a member with the name "properties". The value of the properties member is an object (any JSON object or a JSON null value). - featureProperties :: (Maybe (M.Map String Model.Value)), - -- | If a Feature has a commonly used identifier, that identifier SHOULD be included as a member of the Feature object with the name "id", and the value of this member is either a JSON string or number. - featureId :: (Maybe Id), - featureBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_Feature = Core.Name "hydra.geojson.model.Feature" - -_Feature_geometry = Core.Name "geometry" - -_Feature_properties = Core.Name "properties" - -_Feature_id = Core.Name "id" - -_Feature_bbox = Core.Name "bbox" - --- | A GeoJSON object with the type "FeatureCollection" is a FeatureCollection object. A FeatureCollection object has a member with the name "features". The value of "features" is a JSON array. Each element of the array is a Feature object as defined above. It is possible for this array to be empty. -data FeatureCollection = - FeatureCollection { - featureCollectionFeatures :: [Feature], - featureCollectionBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_FeatureCollection = Core.Name "hydra.geojson.model.FeatureCollection" - -_FeatureCollection_features = Core.Name "features" - -_FeatureCollection_bbox = Core.Name "bbox" - --- | A Geometry object represents points, curves, and surfaces in coordinate space. Every Geometry object is a GeoJSON object no matter where it occurs in a GeoJSON text. -data Geometry = - GeometryPoint Point | - GeometryMultiPoint MultiPoint | - GeometryLineString LineString | - GeometryMultiLineString MultiLineString | - GeometryPolygon Polygon | - GeometryMultiPolygon MultiPolygon | - GeometryGeometryCollection GeometryCollection - deriving (Eq, Ord, Read, Show) - -_Geometry = Core.Name "hydra.geojson.model.Geometry" - -_Geometry_point = Core.Name "point" - -_Geometry_multiPoint = Core.Name "multiPoint" - -_Geometry_lineString = Core.Name "lineString" - -_Geometry_multiLineString = Core.Name "multiLineString" - -_Geometry_polygon = Core.Name "polygon" - -_Geometry_multiPolygon = Core.Name "multiPolygon" - -_Geometry_geometryCollection = Core.Name "geometryCollection" - --- | A GeoJSON object with type "GeometryCollection" is a Geometry object. A GeometryCollection has a member with the name "geometries". The value of "geometries" is an array. Each element of this array is a GeoJSON Geometry object. It is possible for this array to be empty. -data GeometryCollection = - GeometryCollection { - geometryCollectionGeometries :: [Geometry], - geometryCollectionBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_GeometryCollection = Core.Name "hydra.geojson.model.GeometryCollection" - -_GeometryCollection_geometries = Core.Name "geometries" - -_GeometryCollection_bbox = Core.Name "bbox" - --- | A Feature's commonly used identifier, either a JSON string or a number -data Id = - IdNumber Double | - IdString String - deriving (Eq, Ord, Read, Show) - -_Id = Core.Name "hydra.geojson.model.Id" - -_Id_number = Core.Name "number" - -_Id_string = Core.Name "string" - --- | For type "LineString", the "coordinates" member is an array of two or more positions. -data LineString = - LineString { - lineStringCoordinates :: [Position], - lineStringBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_LineString = Core.Name "hydra.geojson.model.LineString" - -_LineString_coordinates = Core.Name "coordinates" - -_LineString_bbox = Core.Name "bbox" - --- | For type "MultiLineString", the "coordinates" member is an array of LineString coordinate arrays. -data MultiLineString = - MultiLineString { - multiLineStringCoordinates :: [LineString], - multiLineStringBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_MultiLineString = Core.Name "hydra.geojson.model.MultiLineString" - -_MultiLineString_coordinates = Core.Name "coordinates" - -_MultiLineString_bbox = Core.Name "bbox" - --- | For type "MultiPoint", the "coordinates" member is an array of positions. -data MultiPoint = - MultiPoint { - multiPointCoordinates :: [Point], - multiPointBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_MultiPoint = Core.Name "hydra.geojson.model.MultiPoint" - -_MultiPoint_coordinates = Core.Name "coordinates" - -_MultiPoint_bbox = Core.Name "bbox" - --- | For type "MultiPolygon", the "coordinates" member is an array of Polygon coordinate arrays. -data MultiPolygon = - MultiPolygon { - multiPolygonCoordinates :: [Polygon], - multiPolygonBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_MultiPolygon = Core.Name "hydra.geojson.model.MultiPolygon" - -_MultiPolygon_coordinates = Core.Name "coordinates" - -_MultiPolygon_bbox = Core.Name "bbox" - --- | A GeoJSON object represents a Geometry, Feature, or collection of Features. -data Object = - ObjectGeometry Geometry | - ObjectFeature Feature | - ObjectFeatureCollection FeatureCollection - deriving (Eq, Ord, Read, Show) - -_Object = Core.Name "hydra.geojson.model.Object" - -_Object_geometry = Core.Name "geometry" - -_Object_feature = Core.Name "feature" - -_Object_featureCollection = Core.Name "featureCollection" - --- | For type "Point", the "coordinates" member is a single position. -data Point = - Point { - pointCoordinates :: Position, - pointBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_Point = Core.Name "hydra.geojson.model.Point" - -_Point_coordinates = Core.Name "coordinates" - -_Point_bbox = Core.Name "bbox" - --- | For type "Polygon", the "coordinates" member MUST be an array of linear ring coordinate arrays. --- | For Polygons with more than one of these rings, the first MUST be the exterior ring, and any others MUST be interior rings. The exterior ring bounds the surface, and the interior rings (if present) bound holes within the surface. -data Polygon = - Polygon { - polygonCoordinates :: [Position], - polygonBbox :: (Maybe BoundingBox)} - deriving (Eq, Ord, Read, Show) - -_Polygon = Core.Name "hydra.geojson.model.Polygon" - -_Polygon_coordinates = Core.Name "coordinates" - -_Polygon_bbox = Core.Name "bbox" - --- | A position is an array of numbers. There MUST be two or more elements. The first two elements are longitude and latitude, or easting and northing, precisely in that order and using decimal numbers. Altitude or elevation MAY be included as an optional third element. -data Position = - Position { - positionLatitude :: Double, - positionLongitude :: Double, - positionAltitude :: (Maybe Double)} - deriving (Eq, Ord, Read, Show) - -_Position = Core.Name "hydra.geojson.model.Position" - -_Position_latitude = Core.Name "latitude" - -_Position_longitude = Core.Name "longitude" - -_Position_altitude = Core.Name "altitude" diff --git a/src/main/haskell/Hydra/Graphql/Coder.hs b/src/main/haskell/Hydra/Graphql/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Graphql/Coder.hs +++ /dev/null @@ -1,250 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | GraphQL code generator: converts Hydra modules to GraphQL schema definitions - -module Hydra.Graphql.Coder where - -import qualified Hydra.Annotations as Annotations -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.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Graphql.Language as Language -import qualified Hydra.Graphql.Serde as Serde -import qualified Hydra.Graphql.Syntax as Syntax -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -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.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Predicates as Predicates -import qualified Hydra.Print.Core as PrintCore -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Get the description from a type as a GraphQL Description -descriptionFromType :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error (Maybe Syntax.Description) -descriptionFromType cx g typ = - Eithers.map (\mval -> Optionals.map (\s -> Syntax.Description (Syntax.StringValue s)) mval) (Annotations.getTypeDescription cx g typ) - --- | Encode a field name to a GraphQL EnumValue -encodeEnumFieldName :: Core.Name -> Syntax.EnumValue -encodeEnumFieldName name = Syntax.EnumValue (Syntax.Name (sanitize (Core.unName name))) - --- | Encode an enum field type to a GraphQL EnumValueDefinition -encodeEnumFieldType :: t0 -> Graph.Graph -> Core.FieldType -> Either Errors.Error Syntax.EnumValueDefinition -encodeEnumFieldType cx g ft = - Eithers.bind (descriptionFromType cx g (Core.fieldTypeType ft)) (\desc -> Right (Syntax.EnumValueDefinition { - Syntax.enumValueDefinitionDescription = desc, - Syntax.enumValueDefinitionEnumValue = (encodeEnumFieldName (Core.fieldTypeName ft)), - Syntax.enumValueDefinitionDirectives = Nothing})) - --- | Encode a field name to a GraphQL Name -encodeFieldName :: Core.Name -> Syntax.Name -encodeFieldName name = Syntax.Name (sanitize (Core.unName name)) - --- | Encode a field type to a GraphQL FieldDefinition -encodeFieldType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.FieldType -> Either Errors.Error Syntax.FieldDefinition -encodeFieldType cx g prefixes ft = - Eithers.bind (encodeType cx g prefixes (Core.fieldTypeType ft)) (\gtype -> Eithers.bind (descriptionFromType cx g (Core.fieldTypeType ft)) (\desc -> Right (Syntax.FieldDefinition { - Syntax.fieldDefinitionDescription = desc, - Syntax.fieldDefinitionName = (encodeFieldName (Core.fieldTypeName ft)), - Syntax.fieldDefinitionArgumentsDefinition = Nothing, - Syntax.fieldDefinitionType = gtype, - Syntax.fieldDefinitionDirectives = Nothing}))) - --- | Encode a literal type to a GraphQL NamedType -encodeLiteralType :: t0 -> Core.LiteralType -> Either Errors.Error Syntax.NamedType -encodeLiteralType cx lt = - case lt of - Core.LiteralTypeBoolean -> Right (Syntax.NamedType (Syntax.Name "Boolean")) - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat64 -> Right (Syntax.NamedType (Syntax.Name "Float")) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected 64-bit float type, found: " (PrintCore.floatType v0)))) - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeInt32 -> Right (Syntax.NamedType (Syntax.Name "Int")) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected 32-bit signed integer type, found: " (PrintCore.integerType v0)))) - Core.LiteralTypeString -> Right (Syntax.NamedType (Syntax.Name "String")) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible literal type, found: " (PrintCore.literalType lt)))) - --- | Encode a named type to a GraphQL type definition. -encodeNamedType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.Name -> Core.Type -> Either Errors.Error Syntax.TypeDefinition -encodeNamedType cx g prefixes name typ = - case (Strip.deannotateType typ) of - Core.TypeRecord v0 -> Eithers.bind (Eithers.mapList (\f -> encodeFieldType cx g prefixes f) v0) (\gfields -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionObject (Syntax.ObjectTypeDefinition { - Syntax.objectTypeDefinitionDescription = desc, - Syntax.objectTypeDefinitionName = (encodeTypeName prefixes name), - Syntax.objectTypeDefinitionImplementsInterfaces = Nothing, - Syntax.objectTypeDefinitionDirectives = Nothing, - Syntax.objectTypeDefinitionFieldsDefinition = (Just (Syntax.FieldsDefinition gfields))})))) - Core.TypeUnion v0 -> Logic.ifElse (Predicates.isEnumRowType v0) (Eithers.bind (Eithers.mapList (\f -> encodeEnumFieldType cx g f) v0) (\values -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionEnum (Syntax.EnumTypeDefinition { - Syntax.enumTypeDefinitionDescription = desc, - Syntax.enumTypeDefinitionName = (encodeTypeName prefixes name), - Syntax.enumTypeDefinitionDirectives = Nothing, - Syntax.enumTypeDefinitionEnumValuesDefinition = (Just (Syntax.EnumValuesDefinition values))}))))) (Eithers.bind (Eithers.mapList (\f -> encodeUnionFieldType cx g prefixes f) v0) (\gfields -> Eithers.bind (descriptionFromType cx g typ) (\desc -> Right (Syntax.TypeDefinitionObject (Syntax.ObjectTypeDefinition { - Syntax.objectTypeDefinitionDescription = desc, - Syntax.objectTypeDefinitionName = (encodeTypeName prefixes name), - Syntax.objectTypeDefinitionImplementsInterfaces = Nothing, - Syntax.objectTypeDefinitionDirectives = Nothing, - Syntax.objectTypeDefinitionFieldsDefinition = (Just (Syntax.FieldsDefinition gfields))}))))) - Core.TypeEither v0 -> encodeNamedType cx g prefixes name (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "left"), - Core.fieldTypeType = (Core.TypeOptional (Core.eitherTypeLeft v0))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "right"), - Core.fieldTypeType = (Core.TypeOptional (Core.eitherTypeRight v0))}]) - Core.TypePair v0 -> encodeNamedType cx g prefixes name (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "first"), - Core.fieldTypeType = (Core.pairTypeFirst v0)}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "second"), - Core.fieldTypeType = (Core.pairTypeSecond v0)}]) - Core.TypeList v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Core.TypeList v0)) - Core.TypeSet v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Core.TypeList v0)) - Core.TypeMap v0 -> encodeNamedType cx g prefixes name (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "key"), - Core.fieldTypeType = (Core.mapTypeKeys v0)}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "value"), - Core.fieldTypeType = (Core.mapTypeValues v0)}]) - Core.TypeLiteral v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Core.TypeLiteral v0)) - Core.TypeVariable v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Core.TypeVariable v0)) - Core.TypeWrap v0 -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord v0) - Core.TypeUnit -> encodeNamedType cx g prefixes name (Rewriting.wrapTypeToRecord (Core.TypeLiteral Core.LiteralTypeBoolean)) - Core.TypeForall v0 -> encodeNamedType cx g prefixes name (Core.forallTypeBody v0) - Core.TypeApplication v0 -> encodeNamedType cx g prefixes name (Core.applicationTypeFunction v0) - Core.TypeFunction v0 -> encodeNamedType cx g prefixes name (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "domain"), - Core.fieldTypeType = (Core.functionTypeDomain v0)}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "codomain"), - Core.fieldTypeType = (Core.functionTypeCodomain v0)}]) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected record or union type, found: " (PrintCore.type_ typ)))) - --- | Encode a Hydra type as a GraphQL type reference -encodeType :: t0 -> t1 -> M.Map Packaging.ModuleName String -> Core.Type -> Either Errors.Error Syntax.Type -encodeType cx g prefixes typ = - case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> case (Strip.deannotateType v0) of - Core.TypeList v1 -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes v1) - Core.TypeSet v1 -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes v1) - Core.TypeMap v1 -> Eithers.map (\gt -> Syntax.TypeList (Syntax.ListType gt)) (encodeType cx g prefixes (Core.mapTypeValues v1)) - Core.TypeLiteral v1 -> Eithers.map (\nt -> Syntax.TypeNamed nt) (encodeLiteralType cx v1) - Core.TypePair _ -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes (Core.Name "hydra.util.Pair")))) - Core.TypeEither _ -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes (Core.Name "hydra.util.Either")))) - Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) - Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) - Core.TypeWrap v1 -> encodeType cx g prefixes (Core.TypeOptional v1) - Core.TypeVariable v1 -> Right (Syntax.TypeNamed (Syntax.NamedType (encodeTypeName prefixes v1))) - Core.TypeForall v1 -> encodeType cx g prefixes (Core.TypeOptional (Core.forallTypeBody v1)) - Core.TypeApplication v1 -> encodeType cx g prefixes (Core.TypeOptional (Core.applicationTypeFunction v1)) - Core.TypeFunction _ -> Right (Syntax.TypeNamed (Syntax.NamedType (Syntax.Name "String"))) - Core.TypeUnit -> Right (Syntax.TypeNamed (Syntax.NamedType (Syntax.Name "Boolean"))) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible type, found: " (PrintCore.type_ v0)))) - Core.TypeList v0 -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes v0) - Core.TypeSet v0 -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes v0) - Core.TypeMap v0 -> Eithers.map (\gt -> Syntax.TypeNonNull (Syntax.NonNullTypeList (Syntax.ListType gt))) (encodeType cx g prefixes (Core.mapTypeValues v0)) - Core.TypeLiteral v0 -> Eithers.map (\nt -> Syntax.TypeNonNull (Syntax.NonNullTypeNamed nt)) (encodeLiteralType cx v0) - Core.TypePair _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes (Core.Name "hydra.util.Pair"))))) - Core.TypeEither _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes (Core.Name "hydra.util.Either"))))) - Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) - Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) - Core.TypeVariable v0 -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (encodeTypeName prefixes v0)))) - Core.TypeWrap v0 -> encodeType cx g prefixes v0 - Core.TypeForall v0 -> encodeType cx g prefixes (Core.forallTypeBody v0) - Core.TypeApplication v0 -> encodeType cx g prefixes (Core.applicationTypeFunction v0) - Core.TypeFunction _ -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (Syntax.Name "String")))) - Core.TypeUnit -> Right (Syntax.TypeNonNull (Syntax.NonNullTypeNamed (Syntax.NamedType (Syntax.Name "Boolean")))) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected GraphQL-compatible type, found: " (PrintCore.type_ typ)))) - --- | Encode a TypeDefinition to a GraphQL TypeDefinition -encodeTypeDefinition :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Packaging.TypeDefinition -> Either Errors.Error Syntax.TypeDefinition -encodeTypeDefinition cx g prefixes tdef = - encodeNamedType cx g prefixes (Packaging.typeDefinitionName tdef) (Core.typeSchemeBody (Packaging.typeDefinitionBody tdef)) - --- | Encode a Hydra Name as a GraphQL Name with namespace prefix -encodeTypeName :: M.Map Packaging.ModuleName String -> Core.Name -> Syntax.Name -encodeTypeName prefixes name = - - let qualName = Names.qualifyName name - local = Util.qualifiedNameLocal qualName - mns = Util.qualifiedNameModuleName qualName - prefix = Optionals.match mns "" (\ns_ -> Optionals.match (Maps.lookup ns_ prefixes) "" (\p -> p)) - in (Syntax.Name (Strings.concat2 prefix (sanitize local))) - --- | Encode a union variant field type to a nullable GraphQL FieldDefinition. Unit-typed variants become Boolean fields; data-carrying variants use their actual type, made nullable. -encodeUnionFieldType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.FieldType -> Either Errors.Error Syntax.FieldDefinition -encodeUnionFieldType cx g prefixes ft = - - let innerType = Core.fieldTypeType ft - isUnit = Predicates.isUnitType (Strip.deannotateType innerType) - effectiveType = - Logic.ifElse isUnit (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeBoolean)) (Core.TypeOptional innerType) - in (Eithers.bind (encodeType cx g prefixes effectiveType) (\gtype -> Eithers.bind (descriptionFromType cx g innerType) (\desc -> Right (Syntax.FieldDefinition { - Syntax.fieldDefinitionDescription = desc, - Syntax.fieldDefinitionName = (encodeFieldName (Core.fieldTypeName ft)), - Syntax.fieldDefinitionArgumentsDefinition = Nothing, - Syntax.fieldDefinitionType = gtype, - Syntax.fieldDefinitionDirectives = Nothing})))) - --- | Top-level entry point: convert a module to GraphQL schema files. -moduleToGraphql :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String) -moduleToGraphql mod defs cx g = - - let partitioned = Environment.partitionDefinitions defs - typeDefs = Pairs.first partitioned - prefixes = - (\modNs -> \tdefs -> - let namespaces = Lists.distinct (Optionals.givens (Lists.map (\td -> Names.moduleNameOf (Packaging.typeDefinitionName td)) tdefs)) - in (Maps.fromList (Lists.map (\ns_ -> ( - ns_, - (Logic.ifElse (Equality.equal ns_ modNs) "" (Strings.concat2 (Formatting.sanitizeWithUnderscores Sets.empty (Packaging.unModuleName ns_)) "_")))) namespaces))) (Packaging.moduleName mod) typeDefs - filePath = Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "graphql") (Packaging.moduleName mod) - in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g prefixes td) typeDefs) (\gtdefs -> Right (Maps.fromList (Lists.singleton ( - filePath, - (Serialization.printExpr (Serialization.parenthesize (Serde.documentToExpr (Syntax.Document (Lists.map (\gtdef -> Syntax.DefinitionTypeSystem (Syntax.TypeSystemDefinitionOrExtensionDefinition (Syntax.TypeSystemDefinitionType gtdef))) gtdefs)))))))))) - --- | Sanitize a string for use as a GraphQL identifier -sanitize :: String -> String -sanitize s = Formatting.sanitizeWithUnderscores Language.graphqlReservedWords s diff --git a/src/main/haskell/Hydra/Graphql/Language.hs b/src/main/haskell/Hydra/Graphql/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Graphql/Language.hs +++ /dev/null @@ -1,119 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints and reserved words for GraphQL - -module Hydra.Graphql.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | Language constraints for GraphQL -graphqlLanguage :: Coders.Language -graphqlLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.graphql"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "graphql")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = Sets.fromList [ - Core.FloatTypeFloat64] - integerTypes = Sets.fromList [ - Core.IntegerTypeInt32] - termVariants = - Sets.fromList [ - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantOptional, - Variants.TermVariantRecord, - Variants.TermVariantInject] - typeVariants = - Sets.fromList [ - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantForall, - Variants.TypeVariantFunction, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantPair, - Variants.TypeVariantSet, - Variants.TypeVariantUnit, - Variants.TypeVariantWrap, - Variants.TypeVariantOptional, - Variants.TypeVariantRecord, - Variants.TypeVariantUnion, - Variants.TypeVariantVariable] - typePredicate = - \typ -> case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> case (Strip.deannotateType v0) of - Core.TypeOptional _ -> False - _ -> True - _ -> True - --- | A set of reserved words in GraphQL -graphqlReservedWords :: S.Set String -graphqlReservedWords = - Sets.fromList [ - "true", - "false"] diff --git a/src/main/haskell/Hydra/Graphql/Serde.hs b/src/main/haskell/Hydra/Graphql/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Graphql/Serde.hs +++ /dev/null @@ -1,187 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Serialization functions for converting GraphQL AST to abstract expressions - -module Hydra.Graphql.Serde 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.Graphql.Syntax as Syntax -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -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.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Convert a GraphQL definition to an expression -definitionToExpr :: Syntax.Definition -> Ast.Expr -definitionToExpr def = - case def of - Syntax.DefinitionExecutable _ -> Serialization.cst "Unsupported: executable definition" - Syntax.DefinitionTypeSystem v0 -> typeSystemDefinitionOrExtensionToExpr v0 - --- | Convert a GraphQL description to a triple-quoted comment -descriptionToExpr :: Syntax.Description -> Ast.Expr -descriptionToExpr desc = - - let delim = Serialization.cst "\"\"\"" - text = Syntax.unStringValue (Syntax.unDescription desc) - in (Serialization.newlineSep [ - delim, - (Serialization.cst text), - delim]) - --- | Convert a GraphQL document to an expression -documentToExpr :: Syntax.Document -> Ast.Expr -documentToExpr d = Serialization.doubleNewlineSep (Lists.map definitionToExpr (Syntax.unDocument d)) - --- | Convert a GraphQL enum type definition to an expression -enumTypeDefinitionToExpr :: Syntax.EnumTypeDefinition -> Ast.Expr -enumTypeDefinitionToExpr def = - - let desc = Syntax.enumTypeDefinitionDescription def - name = Syntax.enumTypeDefinitionName def - values = Syntax.enumTypeDefinitionEnumValuesDefinition def - valuesExpr = Optionals.match values [] (\vs -> Lists.map enumValueDefinitionToExpr (Syntax.unEnumValuesDefinition vs)) - in (withDescription desc (Serialization.spaceSep [ - Serialization.cst "enum", - (nameToExpr name), - (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle valuesExpr)])) - --- | Convert a GraphQL enum value definition to an expression -enumValueDefinitionToExpr :: Syntax.EnumValueDefinition -> Ast.Expr -enumValueDefinitionToExpr def = - - let desc = Syntax.enumValueDefinitionDescription def - ev = Syntax.enumValueDefinitionEnumValue def - in (withDescription desc (enumValueToExpr ev)) - --- | Convert a GraphQL enum value to an expression -enumValueToExpr :: Syntax.EnumValue -> Ast.Expr -enumValueToExpr ev = nameToExpr (Syntax.unEnumValue ev) - --- | Convert a GraphQL field definition to an expression -fieldDefinitionToExpr :: Syntax.FieldDefinition -> Ast.Expr -fieldDefinitionToExpr def = - - let desc = Syntax.fieldDefinitionDescription def - name = Syntax.fieldDefinitionName def - typ = Syntax.fieldDefinitionType def - namePart = - Serialization.noSep [ - nameToExpr name, - (Serialization.cst ":")] - typePart = typeToExpr typ - in (withDescription desc (Serialization.spaceSep [ - namePart, - typePart])) - --- | Convert a GraphQL list type to an expression -listTypeToExpr :: Syntax.ListType -> Ast.Expr -listTypeToExpr lt = - Serialization.noSep [ - Serialization.cst "[", - (typeToExpr (Syntax.unListType lt)), - (Serialization.cst "]")] - --- | Convert a GraphQL name to an expression -nameToExpr :: Syntax.Name -> Ast.Expr -nameToExpr n = Serialization.cst (Syntax.unName n) - --- | Convert a GraphQL named type to an expression -namedTypeToExpr :: Syntax.NamedType -> Ast.Expr -namedTypeToExpr nt = nameToExpr (Syntax.unNamedType nt) - --- | Convert a GraphQL non-null type to an expression -nonNullTypeToExpr :: Syntax.NonNullType -> Ast.Expr -nonNullTypeToExpr nnt = - - let typeExpr = - case nnt of - Syntax.NonNullTypeNamed v0 -> namedTypeToExpr v0 - Syntax.NonNullTypeList v0 -> listTypeToExpr v0 - in (Serialization.noSep [ - typeExpr, - (Serialization.cst "!")]) - --- | Convert a GraphQL object type definition to an expression -objectTypeDefinitionToExpr :: Syntax.ObjectTypeDefinition -> Ast.Expr -objectTypeDefinitionToExpr def = - - let desc = Syntax.objectTypeDefinitionDescription def - name = Syntax.objectTypeDefinitionName def - fields = Syntax.objectTypeDefinitionFieldsDefinition def - fieldsExpr = Optionals.match fields [] (\fs -> Lists.map fieldDefinitionToExpr (Syntax.unFieldsDefinition fs)) - in (withDescription desc (Serialization.spaceSep [ - Serialization.cst "type", - (nameToExpr name), - (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle fieldsExpr)])) - --- | Convert a GraphQL type definition to an expression -typeDefinitionToExpr :: Syntax.TypeDefinition -> Ast.Expr -typeDefinitionToExpr def = - case def of - Syntax.TypeDefinitionScalar _ -> Serialization.cst "Unsupported: scalar type definition" - Syntax.TypeDefinitionObject v0 -> objectTypeDefinitionToExpr v0 - Syntax.TypeDefinitionInterface _ -> Serialization.cst "Unsupported: interface type definition" - Syntax.TypeDefinitionUnion _ -> Serialization.cst "Unsupported: union type definition" - Syntax.TypeDefinitionEnum v0 -> enumTypeDefinitionToExpr v0 - Syntax.TypeDefinitionInputObject _ -> Serialization.cst "Unsupported: input object type definition" - --- | Convert a GraphQL type system definition or extension to an expression -typeSystemDefinitionOrExtensionToExpr :: Syntax.TypeSystemDefinitionOrExtension -> Ast.Expr -typeSystemDefinitionOrExtensionToExpr de = - case de of - Syntax.TypeSystemDefinitionOrExtensionDefinition v0 -> typeSystemDefinitionToExpr v0 - Syntax.TypeSystemDefinitionOrExtensionExtension _ -> Serialization.cst "Unsupported: type system extension" - --- | Convert a GraphQL type system definition to an expression -typeSystemDefinitionToExpr :: Syntax.TypeSystemDefinition -> Ast.Expr -typeSystemDefinitionToExpr def = - case def of - Syntax.TypeSystemDefinitionSchema _ -> Serialization.cst "Unsupported: schema definition" - Syntax.TypeSystemDefinitionType v0 -> typeDefinitionToExpr v0 - Syntax.TypeSystemDefinitionDirective _ -> Serialization.cst "Unsupported: directive definition" - --- | Convert a GraphQL type to an expression -typeToExpr :: Syntax.Type -> Ast.Expr -typeToExpr typ = - case typ of - Syntax.TypeNamed v0 -> namedTypeToExpr v0 - Syntax.TypeList v0 -> listTypeToExpr v0 - Syntax.TypeNonNull v0 -> nonNullTypeToExpr v0 - --- | Prepend an optional description to an expression -withDescription :: Maybe Syntax.Description -> Ast.Expr -> Ast.Expr -withDescription mdesc expr = - Serialization.newlineSep (Optionals.givens [ - Optionals.map descriptionToExpr mdesc, - (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Graphql/Syntax.hs b/src/main/haskell/Hydra/Graphql/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Graphql/Syntax.hs +++ /dev/null @@ -1,1397 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A GraphQL model. Based on the (extended) BNF at: --- | https://spec.graphql.org/draft/#sec-Appendix-Grammar-Summary - -module Hydra.Graphql.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A GraphQL field alias, immediately followed by a colon. -data Alias = - AliasName Name | - AliasColon - deriving (Eq, Ord, Read, Show) - -_Alias = Core.Name "hydra.graphql.syntax.Alias" - -_Alias_Name = Core.Name "Name" - -_Alias_Colon = Core.Name "Colon" - --- | A single GraphQL argument, consisting of a name and a value. -data Argument = - Argument { - argumentName :: Name, - argumentValue :: Value} - deriving (Eq, Ord, Read, Show) - -_Argument = Core.Name "hydra.graphql.syntax.Argument" - -_Argument_Name = Core.Name "Name" - -_Argument_Value = Core.Name "Value" - --- | A parenthesized list of GraphQL arguments. -newtype Arguments = - Arguments { - unArguments :: [Argument]} - deriving (Eq, Ord, Read, Show) - -_Arguments = Core.Name "hydra.graphql.syntax.Arguments" - --- | A parenthesized list of GraphQL input value definitions for a field's arguments. -newtype ArgumentsDefinition = - ArgumentsDefinition { - unArgumentsDefinition :: [InputValueDefinition]} - deriving (Eq, Ord, Read, Show) - -_ArgumentsDefinition = Core.Name "hydra.graphql.syntax.ArgumentsDefinition" - --- | A GraphQL boolean literal, either true or false. -data BooleanValue = - BooleanValueTrue | - BooleanValueFalse - deriving (Eq, Ord, Read, Show) - -_BooleanValue = Core.Name "hydra.graphql.syntax.BooleanValue" - -_BooleanValue_True = Core.Name "True" - -_BooleanValue_False = Core.Name "False" - --- | A default value for a GraphQL variable or input field, introduced by an equals sign. -newtype DefaultValue = - DefaultValue { - unDefaultValue :: Value} - deriving (Eq, Ord, Read, Show) - -_DefaultValue = Core.Name "hydra.graphql.syntax.DefaultValue" - --- | A top-level GraphQL definition, either executable or part of the type system. -data Definition = - DefinitionExecutable ExecutableDefinition | - DefinitionTypeSystem TypeSystemDefinitionOrExtension - deriving (Eq, Ord, Read, Show) - -_Definition = Core.Name "hydra.graphql.syntax.Definition" - -_Definition_executable = Core.Name "executable" - -_Definition_typeSystem = Core.Name "typeSystem" - --- | An optional string description preceding a GraphQL type system definition. -newtype Description = - Description { - unDescription :: StringValue} - deriving (Eq, Ord, Read, Show) - -_Description = Core.Name "hydra.graphql.syntax.Description" - --- | A single GraphQL directive, consisting of a name and optional arguments. -data Directive = - Directive { - directiveName :: Name, - directiveArguments :: (Maybe Arguments)} - deriving (Eq, Ord, Read, Show) - -_Directive = Core.Name "hydra.graphql.syntax.Directive" - -_Directive_Name = Core.Name "Name" - -_Directive_Arguments = Core.Name "Arguments" - --- | A GraphQL directive definition, giving its name, arguments, repeatability, and locations. -data DirectiveDefinition = - DirectiveDefinition { - directiveDefinitionDescription :: (Maybe Description), - directiveDefinitionName :: Name, - directiveDefinitionArgumentsDefinition :: (Maybe ArgumentsDefinition), - directiveDefinitionRepeatable :: (Maybe ()), - directiveDefinitionDirectiveLocations :: DirectiveLocations} - deriving (Eq, Ord, Read, Show) - -_DirectiveDefinition = Core.Name "hydra.graphql.syntax.DirectiveDefinition" - -_DirectiveDefinition_Description = Core.Name "Description" - -_DirectiveDefinition_Name = Core.Name "Name" - -_DirectiveDefinition_ArgumentsDefinition = Core.Name "ArgumentsDefinition" - -_DirectiveDefinition_Repeatable = Core.Name "Repeatable" - -_DirectiveDefinition_DirectiveLocations = Core.Name "DirectiveLocations" - --- | A location at which a GraphQL directive may be applied, either executable or type-system. -data DirectiveLocation = - DirectiveLocationExecutable ExecutableDirectiveLocation | - DirectiveLocationTypeSystem TypeSystemDirectiveLocation - deriving (Eq, Ord, Read, Show) - -_DirectiveLocation = Core.Name "hydra.graphql.syntax.DirectiveLocation" - -_DirectiveLocation_executable = Core.Name "executable" - -_DirectiveLocation_typeSystem = Core.Name "typeSystem" - --- | A pipe-separated list of GraphQL directive locations. -data DirectiveLocations = - DirectiveLocationsSeq DirectiveLocationsSequence | - DirectiveLocationsSeq2 DirectiveLocationsSequence2 - deriving (Eq, Ord, Read, Show) - -_DirectiveLocations = Core.Name "hydra.graphql.syntax.DirectiveLocations" - -_DirectiveLocations_seq = Core.Name "seq" - -_DirectiveLocations_seq2 = Core.Name "seq2" - --- | A non-empty DirectiveLocations sequence with a leading list of locations. -data DirectiveLocationsSequence = - DirectiveLocationsSequence { - directiveLocationsSequenceDirectiveLocations :: DirectiveLocations, - directiveLocationsSequenceDirectiveLocation :: DirectiveLocation} - deriving (Eq, Ord, Read, Show) - -_DirectiveLocationsSequence = Core.Name "hydra.graphql.syntax.DirectiveLocationsSequence" - -_DirectiveLocationsSequence_DirectiveLocations = Core.Name "DirectiveLocations" - -_DirectiveLocationsSequence_DirectiveLocation = Core.Name "DirectiveLocation" - --- | The base case of a DirectiveLocations sequence: a single, optionally pipe-prefixed location. -data DirectiveLocationsSequence2 = - DirectiveLocationsSequence2 { - directiveLocationsSequence2Or :: (Maybe ()), - directiveLocationsSequence2DirectiveLocation :: DirectiveLocation} - deriving (Eq, Ord, Read, Show) - -_DirectiveLocationsSequence2 = Core.Name "hydra.graphql.syntax.DirectiveLocationsSequence2" - -_DirectiveLocationsSequence2_Or = Core.Name "Or" - -_DirectiveLocationsSequence2_DirectiveLocation = Core.Name "DirectiveLocation" - --- | A list of GraphQL directives applied to a definition or selection. -newtype Directives = - Directives { - unDirectives :: [Directive]} - deriving (Eq, Ord, Read, Show) - -_Directives = Core.Name "hydra.graphql.syntax.Directives" - --- | A GraphQL document, consisting of a list of definitions. -newtype Document = - Document { - unDocument :: [Definition]} - deriving (Eq, Ord, Read, Show) - -_Document = Core.Name "hydra.graphql.syntax.Document" - --- | A GraphQL enum type definition, giving its name, directives, and enum values. -data EnumTypeDefinition = - EnumTypeDefinition { - enumTypeDefinitionDescription :: (Maybe Description), - enumTypeDefinitionName :: Name, - enumTypeDefinitionDirectives :: (Maybe Directives), - enumTypeDefinitionEnumValuesDefinition :: (Maybe EnumValuesDefinition)} - deriving (Eq, Ord, Read, Show) - -_EnumTypeDefinition = Core.Name "hydra.graphql.syntax.EnumTypeDefinition" - -_EnumTypeDefinition_Description = Core.Name "Description" - -_EnumTypeDefinition_Name = Core.Name "Name" - -_EnumTypeDefinition_Directives = Core.Name "Directives" - -_EnumTypeDefinition_EnumValuesDefinition = Core.Name "EnumValuesDefinition" - --- | An extension of a GraphQL enum type, either adding enum values or only directives. -data EnumTypeExtension = - EnumTypeExtensionSeq EnumTypeExtensionSequence | - EnumTypeExtensionSeq2 EnumTypeExtensionSequence2 - deriving (Eq, Ord, Read, Show) - -_EnumTypeExtension = Core.Name "hydra.graphql.syntax.EnumTypeExtension" - -_EnumTypeExtension_seq = Core.Name "seq" - -_EnumTypeExtension_seq2 = Core.Name "seq2" - --- | An enum type extension that adds new enum values, with optional directives. -data EnumTypeExtensionSequence = - EnumTypeExtensionSequence { - enumTypeExtensionSequenceName :: Name, - enumTypeExtensionSequenceDirectives :: (Maybe Directives), - enumTypeExtensionSequenceEnumValuesDefinition :: EnumValuesDefinition} - deriving (Eq, Ord, Read, Show) - -_EnumTypeExtensionSequence = Core.Name "hydra.graphql.syntax.EnumTypeExtensionSequence" - -_EnumTypeExtensionSequence_Name = Core.Name "Name" - -_EnumTypeExtensionSequence_Directives = Core.Name "Directives" - -_EnumTypeExtensionSequence_EnumValuesDefinition = Core.Name "EnumValuesDefinition" - --- | An enum type extension consisting of directives only, with no new enum values. -data EnumTypeExtensionSequence2 = - EnumTypeExtensionSequence2 { - enumTypeExtensionSequence2Name :: Name, - enumTypeExtensionSequence2Directives :: Directives} - deriving (Eq, Ord, Read, Show) - -_EnumTypeExtensionSequence2 = Core.Name "hydra.graphql.syntax.EnumTypeExtensionSequence2" - -_EnumTypeExtensionSequence2_Name = Core.Name "Name" - -_EnumTypeExtensionSequence2_Directives = Core.Name "Directives" - --- | A GraphQL enum value, represented as a name (excluding true, false, and null). -newtype EnumValue = - EnumValue { - unEnumValue :: Name} - deriving (Eq, Ord, Read, Show) - -_EnumValue = Core.Name "hydra.graphql.syntax.EnumValue" - --- | A single value definition within a GraphQL enum type, with optional description and directives. -data EnumValueDefinition = - EnumValueDefinition { - enumValueDefinitionDescription :: (Maybe Description), - enumValueDefinitionEnumValue :: EnumValue, - enumValueDefinitionDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_EnumValueDefinition = Core.Name "hydra.graphql.syntax.EnumValueDefinition" - -_EnumValueDefinition_Description = Core.Name "Description" - -_EnumValueDefinition_EnumValue = Core.Name "EnumValue" - -_EnumValueDefinition_Directives = Core.Name "Directives" - --- | The braced list of enum value definitions in a GraphQL enum type. -newtype EnumValuesDefinition = - EnumValuesDefinition { - unEnumValuesDefinition :: [EnumValueDefinition]} - deriving (Eq, Ord, Read, Show) - -_EnumValuesDefinition = Core.Name "hydra.graphql.syntax.EnumValuesDefinition" - --- | A GraphQL executable definition, either an operation or a fragment definition. -data ExecutableDefinition = - ExecutableDefinitionOperation OperationDefinition | - ExecutableDefinitionFragment FragmentDefinition - deriving (Eq, Ord, Read, Show) - -_ExecutableDefinition = Core.Name "hydra.graphql.syntax.ExecutableDefinition" - -_ExecutableDefinition_operation = Core.Name "operation" - -_ExecutableDefinition_fragment = Core.Name "fragment" - --- | A directive location valid on GraphQL executable definitions (queries, fields, fragments, etc.). -data ExecutableDirectiveLocation = - ExecutableDirectiveLocationQUERY | - ExecutableDirectiveLocationMUTATION | - ExecutableDirectiveLocationSUBSCRIPTION | - ExecutableDirectiveLocationFIELD | - ExecutableDirectiveLocationFRAGMENT_DEFINITION | - ExecutableDirectiveLocationFRAGMENT_SPREAD | - ExecutableDirectiveLocationINLINE_FRAGMENT | - ExecutableDirectiveLocationVARIABLE_DEFINITION - deriving (Eq, Ord, Read, Show) - -_ExecutableDirectiveLocation = Core.Name "hydra.graphql.syntax.ExecutableDirectiveLocation" - -_ExecutableDirectiveLocation_QUERY = Core.Name "QUERY" - -_ExecutableDirectiveLocation_MUTATION = Core.Name "MUTATION" - -_ExecutableDirectiveLocation_SUBSCRIPTION = Core.Name "SUBSCRIPTION" - -_ExecutableDirectiveLocation_FIELD = Core.Name "FIELD" - -_ExecutableDirectiveLocation_FRAGMENT_DEFINITION = Core.Name "FRAGMENT_DEFINITION" - -_ExecutableDirectiveLocation_FRAGMENT_SPREAD = Core.Name "FRAGMENT_SPREAD" - -_ExecutableDirectiveLocation_INLINE_FRAGMENT = Core.Name "INLINE_FRAGMENT" - -_ExecutableDirectiveLocation_VARIABLE_DEFINITION = Core.Name "VARIABLE_DEFINITION" - --- | A GraphQL document consisting only of executable definitions. -newtype ExecutableDocument = - ExecutableDocument { - unExecutableDocument :: [ExecutableDefinition]} - deriving (Eq, Ord, Read, Show) - -_ExecutableDocument = Core.Name "hydra.graphql.syntax.ExecutableDocument" - --- | A GraphQL field selection, with optional alias, arguments, directives, and sub-selection set. -data Field = - Field { - fieldAlias :: (Maybe Alias), - fieldName :: Name, - fieldArguments :: (Maybe Arguments), - fieldDirectives :: (Maybe Directives), - fieldSelectionSet :: (Maybe SelectionSet)} - deriving (Eq, Ord, Read, Show) - -_Field = Core.Name "hydra.graphql.syntax.Field" - -_Field_Alias = Core.Name "Alias" - -_Field_Name = Core.Name "Name" - -_Field_Arguments = Core.Name "Arguments" - -_Field_Directives = Core.Name "Directives" - -_Field_SelectionSet = Core.Name "SelectionSet" - --- | A field definition within a GraphQL object or interface type. -data FieldDefinition = - FieldDefinition { - fieldDefinitionDescription :: (Maybe Description), - fieldDefinitionName :: Name, - fieldDefinitionArgumentsDefinition :: (Maybe ArgumentsDefinition), - fieldDefinitionType :: Type, - fieldDefinitionDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_FieldDefinition = Core.Name "hydra.graphql.syntax.FieldDefinition" - -_FieldDefinition_Description = Core.Name "Description" - -_FieldDefinition_Name = Core.Name "Name" - -_FieldDefinition_ArgumentsDefinition = Core.Name "ArgumentsDefinition" - -_FieldDefinition_Type = Core.Name "Type" - -_FieldDefinition_Directives = Core.Name "Directives" - --- | The braced list of field definitions in a GraphQL object or interface type. -newtype FieldsDefinition = - FieldsDefinition { - unFieldsDefinition :: [FieldDefinition]} - deriving (Eq, Ord, Read, Show) - -_FieldsDefinition = Core.Name "hydra.graphql.syntax.FieldsDefinition" - --- | A GraphQL floating-point literal. -newtype FloatValue = - FloatValue { - unFloatValue :: String} - deriving (Eq, Ord, Read, Show) - -_FloatValue = Core.Name "hydra.graphql.syntax.FloatValue" - --- | A GraphQL fragment definition, naming a type condition and a selection set. -data FragmentDefinition = - FragmentDefinition { - fragmentDefinitionFragmentName :: FragmentName, - fragmentDefinitionTypeCondition :: TypeCondition, - fragmentDefinitionDirectives :: (Maybe Directives), - fragmentDefinitionSelectionSet :: SelectionSet} - deriving (Eq, Ord, Read, Show) - -_FragmentDefinition = Core.Name "hydra.graphql.syntax.FragmentDefinition" - -_FragmentDefinition_FragmentName = Core.Name "FragmentName" - -_FragmentDefinition_TypeCondition = Core.Name "TypeCondition" - -_FragmentDefinition_Directives = Core.Name "Directives" - -_FragmentDefinition_SelectionSet = Core.Name "SelectionSet" - --- | The name of a GraphQL fragment (any name other than "on"). -newtype FragmentName = - FragmentName { - unFragmentName :: Name} - deriving (Eq, Ord, Read, Show) - -_FragmentName = Core.Name "hydra.graphql.syntax.FragmentName" - --- | A GraphQL fragment spread, referencing a named fragment with optional directives. -data FragmentSpread = - FragmentSpread { - fragmentSpreadFragmentName :: FragmentName, - fragmentSpreadDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_FragmentSpread = Core.Name "hydra.graphql.syntax.FragmentSpread" - -_FragmentSpread_FragmentName = Core.Name "FragmentName" - -_FragmentSpread_Directives = Core.Name "Directives" - --- | A clause declaring the interfaces implemented by a GraphQL object or interface type. -data ImplementsInterfaces = - ImplementsInterfacesSeq ImplementsInterfacesSequence | - ImplementsInterfacesSeq2 ImplementsInterfacesSequence2 - deriving (Eq, Ord, Read, Show) - -_ImplementsInterfaces = Core.Name "hydra.graphql.syntax.ImplementsInterfaces" - -_ImplementsInterfaces_seq = Core.Name "seq" - -_ImplementsInterfaces_seq2 = Core.Name "seq2" - --- | A non-empty ImplementsInterfaces list with a leading list of interfaces. -data ImplementsInterfacesSequence = - ImplementsInterfacesSequence { - implementsInterfacesSequenceImplementsInterfaces :: ImplementsInterfaces, - implementsInterfacesSequenceNamedType :: NamedType} - deriving (Eq, Ord, Read, Show) - -_ImplementsInterfacesSequence = Core.Name "hydra.graphql.syntax.ImplementsInterfacesSequence" - -_ImplementsInterfacesSequence_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_ImplementsInterfacesSequence_NamedType = Core.Name "NamedType" - --- | The base case of an ImplementsInterfaces list: a single, optionally ampersand-prefixed interface. -data ImplementsInterfacesSequence2 = - ImplementsInterfacesSequence2 { - implementsInterfacesSequence2Amp :: (Maybe ()), - implementsInterfacesSequence2NamedType :: NamedType} - deriving (Eq, Ord, Read, Show) - -_ImplementsInterfacesSequence2 = Core.Name "hydra.graphql.syntax.ImplementsInterfacesSequence2" - -_ImplementsInterfacesSequence2_Amp = Core.Name "Amp" - -_ImplementsInterfacesSequence2_NamedType = Core.Name "NamedType" - --- | A GraphQL inline fragment, with optional type condition, directives, and a selection set. -data InlineFragment = - InlineFragment { - inlineFragmentTypeCondition :: (Maybe TypeCondition), - inlineFragmentDirectives :: (Maybe Directives), - inlineFragmentSelectionSet :: SelectionSet} - deriving (Eq, Ord, Read, Show) - -_InlineFragment = Core.Name "hydra.graphql.syntax.InlineFragment" - -_InlineFragment_TypeCondition = Core.Name "TypeCondition" - -_InlineFragment_Directives = Core.Name "Directives" - -_InlineFragment_SelectionSet = Core.Name "SelectionSet" - --- | The braced list of input field definitions in a GraphQL input object type. -newtype InputFieldsDefinition = - InputFieldsDefinition { - unInputFieldsDefinition :: [InputValueDefinition]} - deriving (Eq, Ord, Read, Show) - -_InputFieldsDefinition = Core.Name "hydra.graphql.syntax.InputFieldsDefinition" - --- | A GraphQL input object type definition, either with or without input fields. -data InputObjectTypeDefinition = - InputObjectTypeDefinitionSeq InputObjectTypeDefinitionSequence | - InputObjectTypeDefinitionSeq2 InputObjectTypeDefinitionSequence2 - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeDefinition = Core.Name "hydra.graphql.syntax.InputObjectTypeDefinition" - -_InputObjectTypeDefinition_seq = Core.Name "seq" - -_InputObjectTypeDefinition_seq2 = Core.Name "seq2" - --- | An input object type definition that includes an input fields definition. -data InputObjectTypeDefinitionSequence = - InputObjectTypeDefinitionSequence { - inputObjectTypeDefinitionSequenceDescription :: (Maybe Description), - inputObjectTypeDefinitionSequenceName :: Name, - inputObjectTypeDefinitionSequenceDirectives :: (Maybe Directives), - inputObjectTypeDefinitionSequenceInputFieldsDefinition :: InputFieldsDefinition} - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeDefinitionSequence = Core.Name "hydra.graphql.syntax.InputObjectTypeDefinitionSequence" - -_InputObjectTypeDefinitionSequence_Description = Core.Name "Description" - -_InputObjectTypeDefinitionSequence_Name = Core.Name "Name" - -_InputObjectTypeDefinitionSequence_Directives = Core.Name "Directives" - -_InputObjectTypeDefinitionSequence_InputFieldsDefinition = Core.Name "InputFieldsDefinition" - --- | An input object type definition with no input fields definition. -data InputObjectTypeDefinitionSequence2 = - InputObjectTypeDefinitionSequence2 { - inputObjectTypeDefinitionSequence2Description :: (Maybe Description), - inputObjectTypeDefinitionSequence2Name :: Name, - inputObjectTypeDefinitionSequence2Directives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeDefinitionSequence2 = Core.Name "hydra.graphql.syntax.InputObjectTypeDefinitionSequence2" - -_InputObjectTypeDefinitionSequence2_Description = Core.Name "Description" - -_InputObjectTypeDefinitionSequence2_Name = Core.Name "Name" - -_InputObjectTypeDefinitionSequence2_Directives = Core.Name "Directives" - --- | An extension of a GraphQL input object type, either with or without input fields. -data InputObjectTypeExtension = - InputObjectTypeExtensionSeq InputObjectTypeExtensionSequence | - InputObjectTypeExtensionSeq2 InputObjectTypeExtensionSequence2 - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeExtension = Core.Name "hydra.graphql.syntax.InputObjectTypeExtension" - -_InputObjectTypeExtension_seq = Core.Name "seq" - -_InputObjectTypeExtension_seq2 = Core.Name "seq2" - --- | An input object type extension that adds an input fields definition. -data InputObjectTypeExtensionSequence = - InputObjectTypeExtensionSequence { - inputObjectTypeExtensionSequenceName :: Name, - inputObjectTypeExtensionSequenceDirectives :: (Maybe Directives), - inputObjectTypeExtensionSequenceInputFieldsDefinition :: InputFieldsDefinition} - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeExtensionSequence = Core.Name "hydra.graphql.syntax.InputObjectTypeExtensionSequence" - -_InputObjectTypeExtensionSequence_Name = Core.Name "Name" - -_InputObjectTypeExtensionSequence_Directives = Core.Name "Directives" - -_InputObjectTypeExtensionSequence_InputFieldsDefinition = Core.Name "InputFieldsDefinition" - --- | An input object type extension consisting of directives only. -data InputObjectTypeExtensionSequence2 = - InputObjectTypeExtensionSequence2 { - inputObjectTypeExtensionSequence2Name :: Name, - inputObjectTypeExtensionSequence2Directives :: Directives} - deriving (Eq, Ord, Read, Show) - -_InputObjectTypeExtensionSequence2 = Core.Name "hydra.graphql.syntax.InputObjectTypeExtensionSequence2" - -_InputObjectTypeExtensionSequence2_Name = Core.Name "Name" - -_InputObjectTypeExtensionSequence2_Directives = Core.Name "Directives" - --- | A single input value definition, used for field arguments and input object fields. -data InputValueDefinition = - InputValueDefinition { - inputValueDefinitionDescription :: (Maybe Description), - inputValueDefinitionName :: Name, - inputValueDefinitionType :: Type, - inputValueDefinitionDefaultValue :: (Maybe DefaultValue), - inputValueDefinitionDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_InputValueDefinition = Core.Name "hydra.graphql.syntax.InputValueDefinition" - -_InputValueDefinition_Description = Core.Name "Description" - -_InputValueDefinition_Name = Core.Name "Name" - -_InputValueDefinition_Type = Core.Name "Type" - -_InputValueDefinition_DefaultValue = Core.Name "DefaultValue" - -_InputValueDefinition_Directives = Core.Name "Directives" - --- | A GraphQL integer literal. -newtype IntValue = - IntValue { - unIntValue :: String} - deriving (Eq, Ord, Read, Show) - -_IntValue = Core.Name "hydra.graphql.syntax.IntValue" - --- | A GraphQL interface type definition, either with or without a fields definition. -data InterfaceTypeDefinition = - InterfaceTypeDefinitionSeq InterfaceTypeDefinitionSequence | - InterfaceTypeDefinitionSeq2 InterfaceTypeDefinitionSequence2 - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeDefinition = Core.Name "hydra.graphql.syntax.InterfaceTypeDefinition" - -_InterfaceTypeDefinition_seq = Core.Name "seq" - -_InterfaceTypeDefinition_seq2 = Core.Name "seq2" - --- | An interface type definition that includes a fields definition. -data InterfaceTypeDefinitionSequence = - InterfaceTypeDefinitionSequence { - interfaceTypeDefinitionSequenceDescription :: (Maybe Description), - interfaceTypeDefinitionSequenceName :: Name, - interfaceTypeDefinitionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), - interfaceTypeDefinitionSequenceDirectives :: (Maybe Directives), - interfaceTypeDefinitionSequenceFieldsDefinition :: FieldsDefinition} - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeDefinitionSequence = Core.Name "hydra.graphql.syntax.InterfaceTypeDefinitionSequence" - -_InterfaceTypeDefinitionSequence_Description = Core.Name "Description" - -_InterfaceTypeDefinitionSequence_Name = Core.Name "Name" - -_InterfaceTypeDefinitionSequence_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_InterfaceTypeDefinitionSequence_Directives = Core.Name "Directives" - -_InterfaceTypeDefinitionSequence_FieldsDefinition = Core.Name "FieldsDefinition" - --- | An interface type definition with no fields definition. -data InterfaceTypeDefinitionSequence2 = - InterfaceTypeDefinitionSequence2 { - interfaceTypeDefinitionSequence2Description :: (Maybe Description), - interfaceTypeDefinitionSequence2Name :: Name, - interfaceTypeDefinitionSequence2ImplementsInterfaces :: ImplementsInterfaces, - interfaceTypeDefinitionSequence2Directives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeDefinitionSequence2 = Core.Name "hydra.graphql.syntax.InterfaceTypeDefinitionSequence2" - -_InterfaceTypeDefinitionSequence2_Description = Core.Name "Description" - -_InterfaceTypeDefinitionSequence2_Name = Core.Name "Name" - -_InterfaceTypeDefinitionSequence2_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_InterfaceTypeDefinitionSequence2_Directives = Core.Name "Directives" - --- | An extension of a GraphQL interface type, in one of three forms. -data InterfaceTypeExtension = - InterfaceTypeExtensionSeq InterfaceTypeExtensionSequence | - InterfaceTypeExtensionSeq2 InterfaceTypeExtensionSequence2 | - InterfaceTypeExtensionSeq3 InterfaceTypeExtensionSequence3 - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeExtension = Core.Name "hydra.graphql.syntax.InterfaceTypeExtension" - -_InterfaceTypeExtension_seq = Core.Name "seq" - -_InterfaceTypeExtension_seq2 = Core.Name "seq2" - -_InterfaceTypeExtension_seq3 = Core.Name "seq3" - --- | An interface type extension that adds a fields definition. -data InterfaceTypeExtensionSequence = - InterfaceTypeExtensionSequence { - interfaceTypeExtensionSequenceName :: Name, - interfaceTypeExtensionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), - interfaceTypeExtensionSequenceDirectives :: (Maybe Directives), - interfaceTypeExtensionSequenceFieldsDefinition :: FieldsDefinition} - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeExtensionSequence = Core.Name "hydra.graphql.syntax.InterfaceTypeExtensionSequence" - -_InterfaceTypeExtensionSequence_Name = Core.Name "Name" - -_InterfaceTypeExtensionSequence_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_InterfaceTypeExtensionSequence_Directives = Core.Name "Directives" - -_InterfaceTypeExtensionSequence_FieldsDefinition = Core.Name "FieldsDefinition" - --- | An interface type extension that adds directives but no fields definition. -data InterfaceTypeExtensionSequence2 = - InterfaceTypeExtensionSequence2 { - interfaceTypeExtensionSequence2Name :: Name, - interfaceTypeExtensionSequence2ImplementsInterfaces :: (Maybe ImplementsInterfaces), - interfaceTypeExtensionSequence2Directives :: Directives} - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeExtensionSequence2 = Core.Name "hydra.graphql.syntax.InterfaceTypeExtensionSequence2" - -_InterfaceTypeExtensionSequence2_Name = Core.Name "Name" - -_InterfaceTypeExtensionSequence2_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_InterfaceTypeExtensionSequence2_Directives = Core.Name "Directives" - --- | An interface type extension that adds only implemented interfaces. -data InterfaceTypeExtensionSequence3 = - InterfaceTypeExtensionSequence3 { - interfaceTypeExtensionSequence3Name :: Name, - interfaceTypeExtensionSequence3ImplementsInterfaces :: ImplementsInterfaces} - deriving (Eq, Ord, Read, Show) - -_InterfaceTypeExtensionSequence3 = Core.Name "hydra.graphql.syntax.InterfaceTypeExtensionSequence3" - -_InterfaceTypeExtensionSequence3_Name = Core.Name "Name" - -_InterfaceTypeExtensionSequence3_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - --- | A GraphQL list type, wrapping an inner type in square brackets. -newtype ListType = - ListType { - unListType :: Type} - deriving (Eq, Ord, Read, Show) - -_ListType = Core.Name "hydra.graphql.syntax.ListType" - --- | A GraphQL list literal, either empty or containing a sequence of values. -data ListValue = - ListValueSeq ListValueSequence | - ListValueSequence2 [Value] - deriving (Eq, Ord, Read, Show) - -_ListValue = Core.Name "hydra.graphql.syntax.ListValue" - -_ListValue_seq = Core.Name "seq" - -_ListValue_sequence2 = Core.Name "sequence2" - --- | The empty-list form of a GraphQL ListValue. -type ListValueSequence = () - -_ListValueSequence = Core.Name "hydra.graphql.syntax.ListValueSequence" - --- | A GraphQL name: an identifier matching [_A-Za-z][_0-9A-Za-z]*. -newtype Name = - Name { - unName :: String} - deriving (Eq, Ord, Read, Show) - -_Name = Core.Name "hydra.graphql.syntax.Name" - --- | A GraphQL named type, referencing a type by its name. -newtype NamedType = - NamedType { - unNamedType :: Name} - deriving (Eq, Ord, Read, Show) - -_NamedType = Core.Name "hydra.graphql.syntax.NamedType" - --- | A GraphQL non-null type, wrapping a named or list type with a trailing exclamation mark. -data NonNullType = - NonNullTypeNamed NamedType | - NonNullTypeList ListType - deriving (Eq, Ord, Read, Show) - -_NonNullType = Core.Name "hydra.graphql.syntax.NonNullType" - -_NonNullType_named = Core.Name "named" - -_NonNullType_list = Core.Name "list" - --- | The GraphQL null literal. -newtype NullValue = - NullValue { - unNullValue :: ()} - deriving (Eq, Ord, Read, Show) - -_NullValue = Core.Name "hydra.graphql.syntax.NullValue" - --- | A single field of a GraphQL object literal, consisting of a name and a value. -data ObjectField = - ObjectField { - objectFieldName :: Name, - objectFieldValue :: Value} - deriving (Eq, Ord, Read, Show) - -_ObjectField = Core.Name "hydra.graphql.syntax.ObjectField" - -_ObjectField_Name = Core.Name "Name" - -_ObjectField_Value = Core.Name "Value" - --- | A GraphQL object type definition, giving its name, interfaces, directives, and fields. -data ObjectTypeDefinition = - ObjectTypeDefinition { - objectTypeDefinitionDescription :: (Maybe Description), - objectTypeDefinitionName :: Name, - objectTypeDefinitionImplementsInterfaces :: (Maybe ImplementsInterfaces), - objectTypeDefinitionDirectives :: (Maybe Directives), - objectTypeDefinitionFieldsDefinition :: (Maybe FieldsDefinition)} - deriving (Eq, Ord, Read, Show) - -_ObjectTypeDefinition = Core.Name "hydra.graphql.syntax.ObjectTypeDefinition" - -_ObjectTypeDefinition_Description = Core.Name "Description" - -_ObjectTypeDefinition_Name = Core.Name "Name" - -_ObjectTypeDefinition_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_ObjectTypeDefinition_Directives = Core.Name "Directives" - -_ObjectTypeDefinition_FieldsDefinition = Core.Name "FieldsDefinition" - --- | An extension of a GraphQL object type, in one of three forms. -data ObjectTypeExtension = - ObjectTypeExtensionSeq ObjectTypeExtensionSequence | - ObjectTypeExtensionSeq2 ObjectTypeExtensionSequence2 | - ObjectTypeExtensionSeq3 ObjectTypeExtensionSequence3 - deriving (Eq, Ord, Read, Show) - -_ObjectTypeExtension = Core.Name "hydra.graphql.syntax.ObjectTypeExtension" - -_ObjectTypeExtension_seq = Core.Name "seq" - -_ObjectTypeExtension_seq2 = Core.Name "seq2" - -_ObjectTypeExtension_seq3 = Core.Name "seq3" - --- | An object type extension that adds a fields definition. -data ObjectTypeExtensionSequence = - ObjectTypeExtensionSequence { - objectTypeExtensionSequenceName :: Name, - objectTypeExtensionSequenceImplementsInterfaces :: (Maybe ImplementsInterfaces), - objectTypeExtensionSequenceDirectives :: (Maybe Directives), - objectTypeExtensionSequenceFieldsDefinition :: FieldsDefinition} - deriving (Eq, Ord, Read, Show) - -_ObjectTypeExtensionSequence = Core.Name "hydra.graphql.syntax.ObjectTypeExtensionSequence" - -_ObjectTypeExtensionSequence_Name = Core.Name "Name" - -_ObjectTypeExtensionSequence_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_ObjectTypeExtensionSequence_Directives = Core.Name "Directives" - -_ObjectTypeExtensionSequence_FieldsDefinition = Core.Name "FieldsDefinition" - --- | An object type extension that adds directives but no fields definition. -data ObjectTypeExtensionSequence2 = - ObjectTypeExtensionSequence2 { - objectTypeExtensionSequence2Name :: Name, - objectTypeExtensionSequence2ImplementsInterfaces :: (Maybe ImplementsInterfaces), - objectTypeExtensionSequence2Directives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_ObjectTypeExtensionSequence2 = Core.Name "hydra.graphql.syntax.ObjectTypeExtensionSequence2" - -_ObjectTypeExtensionSequence2_Name = Core.Name "Name" - -_ObjectTypeExtensionSequence2_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - -_ObjectTypeExtensionSequence2_Directives = Core.Name "Directives" - --- | An object type extension that adds only implemented interfaces. -data ObjectTypeExtensionSequence3 = - ObjectTypeExtensionSequence3 { - objectTypeExtensionSequence3Name :: Name, - objectTypeExtensionSequence3ImplementsInterfaces :: ImplementsInterfaces} - deriving (Eq, Ord, Read, Show) - -_ObjectTypeExtensionSequence3 = Core.Name "hydra.graphql.syntax.ObjectTypeExtensionSequence3" - -_ObjectTypeExtensionSequence3_Name = Core.Name "Name" - -_ObjectTypeExtensionSequence3_ImplementsInterfaces = Core.Name "ImplementsInterfaces" - --- | A GraphQL object literal, either empty or containing a sequence of object fields. -data ObjectValue = - ObjectValueSeq ObjectValueSequence | - ObjectValueSequence2 [ObjectField] - deriving (Eq, Ord, Read, Show) - -_ObjectValue = Core.Name "hydra.graphql.syntax.ObjectValue" - -_ObjectValue_seq = Core.Name "seq" - -_ObjectValue_sequence2 = Core.Name "sequence2" - --- | The empty-object form of a GraphQL ObjectValue. -type ObjectValueSequence = () - -_ObjectValueSequence = Core.Name "hydra.graphql.syntax.ObjectValueSequence" - --- | A GraphQL operation definition, either a shorthand query or an explicit operation. -data OperationDefinition = - OperationDefinitionSeq OperationDefinitionSequence | - OperationDefinitionSelectionSet SelectionSet - deriving (Eq, Ord, Read, Show) - -_OperationDefinition = Core.Name "hydra.graphql.syntax.OperationDefinition" - -_OperationDefinition_seq = Core.Name "seq" - -_OperationDefinition_SelectionSet = Core.Name "SelectionSet" - --- | An explicit GraphQL operation definition with a type, optional name, variables, and directives. -data OperationDefinitionSequence = - OperationDefinitionSequence { - operationDefinitionSequenceOperationType :: OperationType, - operationDefinitionSequenceName :: (Maybe Name), - operationDefinitionSequenceVariablesDefinition :: (Maybe VariablesDefinition), - operationDefinitionSequenceDirectives :: (Maybe Directives), - operationDefinitionSequenceSelectionSet :: SelectionSet} - deriving (Eq, Ord, Read, Show) - -_OperationDefinitionSequence = Core.Name "hydra.graphql.syntax.OperationDefinitionSequence" - -_OperationDefinitionSequence_OperationType = Core.Name "OperationType" - -_OperationDefinitionSequence_Name = Core.Name "Name" - -_OperationDefinitionSequence_VariablesDefinition = Core.Name "VariablesDefinition" - -_OperationDefinitionSequence_Directives = Core.Name "Directives" - -_OperationDefinitionSequence_SelectionSet = Core.Name "SelectionSet" - --- | The type of a GraphQL operation: query, mutation, or subscription. -data OperationType = - OperationTypeQuery | - OperationTypeMutation | - OperationTypeSubscription - deriving (Eq, Ord, Read, Show) - -_OperationType = Core.Name "hydra.graphql.syntax.OperationType" - -_OperationType_Query = Core.Name "Query" - -_OperationType_Mutation = Core.Name "Mutation" - -_OperationType_Subscription = Core.Name "Subscription" - --- | A mapping from a GraphQL operation type to its root object type. -data RootOperationTypeDefinition = - RootOperationTypeDefinition { - rootOperationTypeDefinitionOperationType :: OperationType, - rootOperationTypeDefinitionNamedType :: NamedType} - deriving (Eq, Ord, Read, Show) - -_RootOperationTypeDefinition = Core.Name "hydra.graphql.syntax.RootOperationTypeDefinition" - -_RootOperationTypeDefinition_OperationType = Core.Name "OperationType" - -_RootOperationTypeDefinition_NamedType = Core.Name "NamedType" - --- | A GraphQL scalar type definition, with optional description and directives. -data ScalarTypeDefinition = - ScalarTypeDefinition { - scalarTypeDefinitionDescription :: (Maybe Description), - scalarTypeDefinitionName :: Name, - scalarTypeDefinitionDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_ScalarTypeDefinition = Core.Name "hydra.graphql.syntax.ScalarTypeDefinition" - -_ScalarTypeDefinition_Description = Core.Name "Description" - -_ScalarTypeDefinition_Name = Core.Name "Name" - -_ScalarTypeDefinition_Directives = Core.Name "Directives" - --- | An extension of a GraphQL scalar type, adding directives. -data ScalarTypeExtension = - ScalarTypeExtension { - scalarTypeExtensionName :: Name, - scalarTypeExtensionDirectives :: Directives} - deriving (Eq, Ord, Read, Show) - -_ScalarTypeExtension = Core.Name "hydra.graphql.syntax.ScalarTypeExtension" - -_ScalarTypeExtension_Name = Core.Name "Name" - -_ScalarTypeExtension_Directives = Core.Name "Directives" - --- | A GraphQL schema definition, declaring its root operation types. -data SchemaDefinition = - SchemaDefinition { - schemaDefinitionDescription :: (Maybe Description), - schemaDefinitionDirectives :: (Maybe Directives), - schemaDefinitionRootOperationTypeDefinition :: RootOperationTypeDefinition} - deriving (Eq, Ord, Read, Show) - -_SchemaDefinition = Core.Name "hydra.graphql.syntax.SchemaDefinition" - -_SchemaDefinition_Description = Core.Name "Description" - -_SchemaDefinition_Directives = Core.Name "Directives" - -_SchemaDefinition_RootOperationTypeDefinition = Core.Name "RootOperationTypeDefinition" - --- | An extension of a GraphQL schema, adding root operation types or directives. -data SchemaExtension = - SchemaExtensionSeq SchemaExtensionSequence | - SchemaExtensionSequence2 Directives - deriving (Eq, Ord, Read, Show) - -_SchemaExtension = Core.Name "hydra.graphql.syntax.SchemaExtension" - -_SchemaExtension_seq = Core.Name "seq" - -_SchemaExtension_sequence2 = Core.Name "sequence2" - --- | A schema extension that adds a root operation type definition. -data SchemaExtensionSequence = - SchemaExtensionSequence { - schemaExtensionSequenceDirectives :: (Maybe Directives), - schemaExtensionSequenceRootOperationTypeDefinition :: RootOperationTypeDefinition} - deriving (Eq, Ord, Read, Show) - -_SchemaExtensionSequence = Core.Name "hydra.graphql.syntax.SchemaExtensionSequence" - -_SchemaExtensionSequence_Directives = Core.Name "Directives" - -_SchemaExtensionSequence_RootOperationTypeDefinition = Core.Name "RootOperationTypeDefinition" - --- | A single selection within a GraphQL selection set: a field, fragment spread, or inline fragment. -data Selection = - SelectionField Field | - SelectionFragmentSpread FragmentSpread | - SelectionInlineFragment InlineFragment - deriving (Eq, Ord, Read, Show) - -_Selection = Core.Name "hydra.graphql.syntax.Selection" - -_Selection_Field = Core.Name "Field" - -_Selection_FragmentSpread = Core.Name "FragmentSpread" - -_Selection_InlineFragment = Core.Name "InlineFragment" - --- | A braced list of GraphQL selections. -newtype SelectionSet = - SelectionSet { - unSelectionSet :: [Selection]} - deriving (Eq, Ord, Read, Show) - -_SelectionSet = Core.Name "hydra.graphql.syntax.SelectionSet" - --- | A GraphQL string literal. -newtype StringValue = - StringValue { - unStringValue :: String} - deriving (Eq, Ord, Read, Show) - -_StringValue = Core.Name "hydra.graphql.syntax.StringValue" - --- | A GraphQL type reference: named, list, or non-null. -data Type = - TypeNamed NamedType | - TypeList ListType | - TypeNonNull NonNullType - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.graphql.syntax.Type" - -_Type_named = Core.Name "named" - -_Type_list = Core.Name "list" - -_Type_nonNull = Core.Name "nonNull" - --- | A GraphQL type condition, naming the type a fragment applies to. -data TypeCondition = - TypeConditionOn | - TypeConditionNamedType NamedType - deriving (Eq, Ord, Read, Show) - -_TypeCondition = Core.Name "hydra.graphql.syntax.TypeCondition" - -_TypeCondition_On = Core.Name "On" - -_TypeCondition_NamedType = Core.Name "NamedType" - --- | A GraphQL type system definition for a single named type. -data TypeDefinition = - TypeDefinitionScalar ScalarTypeDefinition | - TypeDefinitionObject ObjectTypeDefinition | - TypeDefinitionInterface InterfaceTypeDefinition | - TypeDefinitionUnion UnionTypeDefinition | - TypeDefinitionEnum EnumTypeDefinition | - TypeDefinitionInputObject InputObjectTypeDefinition - deriving (Eq, Ord, Read, Show) - -_TypeDefinition = Core.Name "hydra.graphql.syntax.TypeDefinition" - -_TypeDefinition_scalar = Core.Name "scalar" - -_TypeDefinition_object = Core.Name "object" - -_TypeDefinition_interface = Core.Name "interface" - -_TypeDefinition_union = Core.Name "union" - -_TypeDefinition_enum = Core.Name "enum" - -_TypeDefinition_inputObject = Core.Name "inputObject" - --- | An extension of a GraphQL named type. -data TypeExtension = - TypeExtensionScalar ScalarTypeExtension | - TypeExtensionObject ObjectTypeExtension | - TypeExtensionInterface InterfaceTypeExtension | - TypeExtensionUnion UnionTypeExtension | - TypeExtensionEnum EnumTypeExtension | - TypeExtensionInputObject InputObjectTypeExtension - deriving (Eq, Ord, Read, Show) - -_TypeExtension = Core.Name "hydra.graphql.syntax.TypeExtension" - -_TypeExtension_scalar = Core.Name "scalar" - -_TypeExtension_object = Core.Name "object" - -_TypeExtension_interface = Core.Name "interface" - -_TypeExtension_union = Core.Name "union" - -_TypeExtension_enum = Core.Name "enum" - -_TypeExtension_inputObject = Core.Name "inputObject" - --- | A GraphQL type system definition: schema, type, or directive. -data TypeSystemDefinition = - TypeSystemDefinitionSchema SchemaDefinition | - TypeSystemDefinitionType TypeDefinition | - TypeSystemDefinitionDirective DirectiveDefinition - deriving (Eq, Ord, Read, Show) - -_TypeSystemDefinition = Core.Name "hydra.graphql.syntax.TypeSystemDefinition" - -_TypeSystemDefinition_schema = Core.Name "schema" - -_TypeSystemDefinition_type = Core.Name "type" - -_TypeSystemDefinition_directive = Core.Name "directive" - --- | Either a GraphQL type system definition or an extension of one. -data TypeSystemDefinitionOrExtension = - TypeSystemDefinitionOrExtensionDefinition TypeSystemDefinition | - TypeSystemDefinitionOrExtensionExtension TypeSystemExtension - deriving (Eq, Ord, Read, Show) - -_TypeSystemDefinitionOrExtension = Core.Name "hydra.graphql.syntax.TypeSystemDefinitionOrExtension" - -_TypeSystemDefinitionOrExtension_definition = Core.Name "definition" - -_TypeSystemDefinitionOrExtension_extension = Core.Name "extension" - --- | A directive location valid on GraphQL type system definitions. -data TypeSystemDirectiveLocation = - TypeSystemDirectiveLocationSCHEMA | - TypeSystemDirectiveLocationSCALAR | - TypeSystemDirectiveLocationOBJECT | - TypeSystemDirectiveLocationFIELD_DEFINITION | - TypeSystemDirectiveLocationARGUMENT_DEFINITION | - TypeSystemDirectiveLocationINTERFACE | - TypeSystemDirectiveLocationUNION | - TypeSystemDirectiveLocationENUM | - TypeSystemDirectiveLocationENUM_VALUE | - TypeSystemDirectiveLocationINPUT_OBJECT | - TypeSystemDirectiveLocationINPUT_FIELD_DEFINITION - deriving (Eq, Ord, Read, Show) - -_TypeSystemDirectiveLocation = Core.Name "hydra.graphql.syntax.TypeSystemDirectiveLocation" - -_TypeSystemDirectiveLocation_SCHEMA = Core.Name "SCHEMA" - -_TypeSystemDirectiveLocation_SCALAR = Core.Name "SCALAR" - -_TypeSystemDirectiveLocation_OBJECT = Core.Name "OBJECT" - -_TypeSystemDirectiveLocation_FIELD_DEFINITION = Core.Name "FIELD_DEFINITION" - -_TypeSystemDirectiveLocation_ARGUMENT_DEFINITION = Core.Name "ARGUMENT_DEFINITION" - -_TypeSystemDirectiveLocation_INTERFACE = Core.Name "INTERFACE" - -_TypeSystemDirectiveLocation_UNION = Core.Name "UNION" - -_TypeSystemDirectiveLocation_ENUM = Core.Name "ENUM" - -_TypeSystemDirectiveLocation_ENUM_VALUE = Core.Name "ENUM_VALUE" - -_TypeSystemDirectiveLocation_INPUT_OBJECT = Core.Name "INPUT_OBJECT" - -_TypeSystemDirectiveLocation_INPUT_FIELD_DEFINITION = Core.Name "INPUT_FIELD_DEFINITION" - --- | A GraphQL document consisting only of type system definitions. -newtype TypeSystemDocment = - TypeSystemDocment { - unTypeSystemDocment :: [TypeSystemDefinition]} - deriving (Eq, Ord, Read, Show) - -_TypeSystemDocment = Core.Name "hydra.graphql.syntax.TypeSystemDocment" - --- | An extension of a GraphQL schema or type. -data TypeSystemExtension = - TypeSystemExtensionSchema SchemaExtension | - TypeSystemExtensionType TypeExtension - deriving (Eq, Ord, Read, Show) - -_TypeSystemExtension = Core.Name "hydra.graphql.syntax.TypeSystemExtension" - -_TypeSystemExtension_schema = Core.Name "schema" - -_TypeSystemExtension_type = Core.Name "type" - --- | A GraphQL document consisting of type system definitions and extensions. -newtype TypeSystemExtensionDocument = - TypeSystemExtensionDocument { - unTypeSystemExtensionDocument :: [TypeSystemDefinitionOrExtension]} - deriving (Eq, Ord, Read, Show) - -_TypeSystemExtensionDocument = Core.Name "hydra.graphql.syntax.TypeSystemExtensionDocument" - --- | The list of member types of a GraphQL union type, introduced by an equals sign. -data UnionMemberTypes = - UnionMemberTypesSeq UnionMemberTypesSequence | - UnionMemberTypesSeq2 UnionMemberTypesSequence2 - deriving (Eq, Ord, Read, Show) - -_UnionMemberTypes = Core.Name "hydra.graphql.syntax.UnionMemberTypes" - -_UnionMemberTypes_seq = Core.Name "seq" - -_UnionMemberTypes_seq2 = Core.Name "seq2" - --- | A non-empty UnionMemberTypes list with a leading list of member types. -data UnionMemberTypesSequence = - UnionMemberTypesSequence { - unionMemberTypesSequenceUnionMemberTypes :: UnionMemberTypes, - unionMemberTypesSequenceNamedType :: NamedType} - deriving (Eq, Ord, Read, Show) - -_UnionMemberTypesSequence = Core.Name "hydra.graphql.syntax.UnionMemberTypesSequence" - -_UnionMemberTypesSequence_UnionMemberTypes = Core.Name "UnionMemberTypes" - -_UnionMemberTypesSequence_NamedType = Core.Name "NamedType" - --- | The base case of a UnionMemberTypes list: a single, optionally pipe-prefixed member type. -data UnionMemberTypesSequence2 = - UnionMemberTypesSequence2 { - unionMemberTypesSequence2Or :: (Maybe ()), - unionMemberTypesSequence2NamedType :: NamedType} - deriving (Eq, Ord, Read, Show) - -_UnionMemberTypesSequence2 = Core.Name "hydra.graphql.syntax.UnionMemberTypesSequence2" - -_UnionMemberTypesSequence2_Or = Core.Name "Or" - -_UnionMemberTypesSequence2_NamedType = Core.Name "NamedType" - --- | A GraphQL union type definition, giving its name, directives, and member types. -data UnionTypeDefinition = - UnionTypeDefinition { - unionTypeDefinitionDescription :: (Maybe Description), - unionTypeDefinitionName :: Name, - unionTypeDefinitionDirectives :: (Maybe Directives), - unionTypeDefinitionUnionMemberTypes :: (Maybe UnionMemberTypes)} - deriving (Eq, Ord, Read, Show) - -_UnionTypeDefinition = Core.Name "hydra.graphql.syntax.UnionTypeDefinition" - -_UnionTypeDefinition_Description = Core.Name "Description" - -_UnionTypeDefinition_Name = Core.Name "Name" - -_UnionTypeDefinition_Directives = Core.Name "Directives" - -_UnionTypeDefinition_UnionMemberTypes = Core.Name "UnionMemberTypes" - --- | An extension of a GraphQL union type, either adding member types or only directives. -data UnionTypeExtension = - UnionTypeExtensionSeq UnionTypeExtensionSequence | - UnionTypeExtensionSeq2 UnionTypeExtensionSequence2 - deriving (Eq, Ord, Read, Show) - -_UnionTypeExtension = Core.Name "hydra.graphql.syntax.UnionTypeExtension" - -_UnionTypeExtension_seq = Core.Name "seq" - -_UnionTypeExtension_seq2 = Core.Name "seq2" - --- | A union type extension that adds new member types. -data UnionTypeExtensionSequence = - UnionTypeExtensionSequence { - unionTypeExtensionSequenceName :: Name, - unionTypeExtensionSequenceDirectives :: (Maybe Directives), - unionTypeExtensionSequenceUnionMemberTypes :: UnionMemberTypes} - deriving (Eq, Ord, Read, Show) - -_UnionTypeExtensionSequence = Core.Name "hydra.graphql.syntax.UnionTypeExtensionSequence" - -_UnionTypeExtensionSequence_Name = Core.Name "Name" - -_UnionTypeExtensionSequence_Directives = Core.Name "Directives" - -_UnionTypeExtensionSequence_UnionMemberTypes = Core.Name "UnionMemberTypes" - --- | A union type extension consisting of directives only. -data UnionTypeExtensionSequence2 = - UnionTypeExtensionSequence2 { - unionTypeExtensionSequence2Name :: Name, - unionTypeExtensionSequence2Directives :: Directives} - deriving (Eq, Ord, Read, Show) - -_UnionTypeExtensionSequence2 = Core.Name "hydra.graphql.syntax.UnionTypeExtensionSequence2" - -_UnionTypeExtensionSequence2_Name = Core.Name "Name" - -_UnionTypeExtensionSequence2_Directives = Core.Name "Directives" - --- | A GraphQL value: a variable, literal, list, or object. -data Value = - ValueVariable Variable | - ValueInt IntValue | - ValueFloat FloatValue | - ValueString StringValue | - ValueBoolean BooleanValue | - ValueNull NullValue | - ValueEnum EnumValue | - ValueList ListValue | - ValueObject ObjectValue - deriving (Eq, Ord, Read, Show) - -_Value = Core.Name "hydra.graphql.syntax.Value" - -_Value_Variable = Core.Name "Variable" - -_Value_int = Core.Name "int" - -_Value_float = Core.Name "float" - -_Value_string = Core.Name "string" - -_Value_boolean = Core.Name "boolean" - -_Value_null = Core.Name "null" - -_Value_enum = Core.Name "enum" - -_Value_list = Core.Name "list" - -_Value_object = Core.Name "object" - --- | A GraphQL variable reference, introduced by a dollar sign. -newtype Variable = - Variable { - unVariable :: Name} - deriving (Eq, Ord, Read, Show) - -_Variable = Core.Name "hydra.graphql.syntax.Variable" - --- | A single variable definition in a GraphQL operation's variable list. -data VariablesDefinition = - VariablesDefinition { - variablesDefinitionVariable :: Variable, - variablesDefinitionType :: Type, - variablesDefinitionDefaultValue :: (Maybe DefaultValue), - variablesDefinitionDirectives :: (Maybe Directives)} - deriving (Eq, Ord, Read, Show) - -_VariablesDefinition = Core.Name "hydra.graphql.syntax.VariablesDefinition" - -_VariablesDefinition_Variable = Core.Name "Variable" - -_VariablesDefinition_Type = Core.Name "Type" - -_VariablesDefinition_DefaultValue = Core.Name "DefaultValue" - -_VariablesDefinition_Directives = Core.Name "Directives" diff --git a/src/main/haskell/Hydra/Iana/Linkrelations.hs b/src/main/haskell/Hydra/Iana/Linkrelations.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Iana/Linkrelations.hs +++ /dev/null @@ -1,500 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | All IANA Link Relation Types, as of 2022-10-11. See https://www.iana.org/assignments/link-relations/link-relations.xhtml - -module Hydra.Iana.Linkrelations where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | An IANA link relation type -data LinkRelationType = - -- | Refers to a resource that is the subject of the link's context. [RFC6903], section 2 - LinkRelationTypeAbout | - -- | Asserts that the link target provides an access control resource for the link context. [https://solidproject.org/TR/wac#acl-link-relation] - LinkRelationTypeAcl | - -- | Refers to a substitute for this context [HTML] - LinkRelationTypeAlternate | - -- | Used to reference alternative content that uses the AMP profile of the HTML format. [AMP HTML] - LinkRelationTypeAmphtml | - -- | Refers to an appendix. [HTML 4.01 Specification] - LinkRelationTypeAppendix | - -- | Refers to an icon for the context. Synonym for icon. [Configuring Web Applications] - LinkRelationTypeApple_touch_icon | - -- | Refers to a launch screen for the context. [Configuring Web Applications] - LinkRelationTypeApple_touch_startup_image | - -- | Refers to a collection of records, documents, or other materials of historical interest. [HTML5] - LinkRelationTypeArchives | - -- | Refers to the context's author. [HTML] - LinkRelationTypeAuthor | - -- | Identifies the entity that blocks access to a resource following receipt of a legal demand. [RFC7725] - LinkRelationTypeBlocked_by | - -- | Gives a permanent link to use for bookmarking purposes. [HTML] - LinkRelationTypeBookmark | - -- | Designates the preferred version of a resource (the IRI and its contents). [RFC6596] - LinkRelationTypeCanonical | - -- | Refers to a chapter in a collection of resources. [HTML 4.01 Specification] - LinkRelationTypeChapter | - -- | Indicates that the link target is preferred over the link context for the purpose of permanent citation. [RFC8574] - LinkRelationTypeCite_as | - -- | The target IRI points to a resource which represents the collection resource for the context IRI. [RFC6573] - LinkRelationTypeCollection | - -- | Refers to a table of contents. [HTML 4.01 Specification] - LinkRelationTypeContents | - -- | The document linked to was later converted to the document that contains this link relation. For example, an RFC can have a link to the Internet-Draft that became the RFC; in that case, the link relation would be "convertedFrom". [RFC7991] This relation is different than "predecessor-version" in that "predecessor-version" is for items in a version control system. It is also different than "previous" in that this relation is used for converted resources, not those that are part of a sequence of resources. - LinkRelationTypeConvertedfrom | - -- | Refers to a copyright statement that applies to the link's context. [HTML 4.01 Specification] - LinkRelationTypeCopyright | - -- | The target IRI points to a resource where a submission form can be obtained. [RFC6861] - LinkRelationTypeCreate_form | - -- | Refers to a resource containing the most recent item(s) in a collection of resources. [RFC5005] - LinkRelationTypeCurrent | - -- | Refers to a resource providing information about the link's context. [Protocol for Web Description Resources (POWDER)] - LinkRelationTypeDescribedby | - -- | The relationship A 'describes' B asserts that resource A provides a description of resource B. There are no constraints on the format or representation of either A or B, neither are there any further constraints on either resource. [RFC6892] This link relation type is the inverse of the 'describedby' relation type. While 'describedby' establishes a relation from the described resource back to the resource that describes it, 'describes' established a relation from the describing resource to the resource it describes. If B is 'describedby' A, then A 'describes' B. - LinkRelationTypeDescribes | - -- | Refers to a list of patent disclosures made with respect to material for which 'disclosure' relation is specified. [RFC6579] - LinkRelationTypeDisclosure | - -- | Used to indicate an origin that will be used to fetch required resources for the link context, and that the user agent ought to resolve as early as possible. [Resource Hints] - LinkRelationTypeDns_prefetch | - -- | Refers to a resource whose available representations are byte-for-byte identical with the corresponding representations of the context IRI. [RFC6249] This relation is for static resources. That is, an HTTP GET request on any duplicate will return the same representation. It does not make sense for dynamic or POSTable resources and should not be used for them. - LinkRelationTypeDuplicate | - -- | Refers to a resource that can be used to edit the link's context. [RFC5023] - LinkRelationTypeEdit | - -- | The target IRI points to a resource where a submission form for editing associated resource can be obtained. [RFC6861] - LinkRelationTypeEdit_form | - -- | Refers to a resource that can be used to edit media associated with the link's context. [RFC5023] - LinkRelationTypeEdit_media | - -- | Identifies a related resource that is potentially large and might require special handling. [RFC4287] - LinkRelationTypeEnclosure | - -- | Refers to a resource that is not part of the same site as the current context. [HTML] - LinkRelationTypeExternal | - -- | An IRI that refers to the furthest preceding resource in a series of resources. [RFC8288] This relation type registration did not indicate a reference. Originally requested by Mark Nottingham in December 2004. - LinkRelationTypeFirst | - -- | Refers to a glossary of terms. [HTML 4.01 Specification] - LinkRelationTypeGlossary | - -- | Refers to context-sensitive help. [HTML] - LinkRelationTypeHelp | - -- | Refers to a resource hosted by the server indicated by the link context. [RFC6690] This relation is used in CoRE where links are retrieved as a "/.well-known/core" resource representation, and is the default relation type in the CoRE Link Format. - LinkRelationTypeHosts | - -- | Refers to a hub that enables registration for notification of updates to the context. [WebSub] This relation type was requested by Brett Slatkin. - LinkRelationTypeHub | - -- | Refers to an icon representing the link's context. [HTML] - LinkRelationTypeIcon | - -- | Refers to an index. [HTML 4.01 Specification] - LinkRelationTypeIndex | - -- | refers to a resource associated with a time interval that ends before the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.21 - LinkRelationTypeIntervalafter | - -- | refers to a resource associated with a time interval that begins after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.22 - LinkRelationTypeIntervalbefore | - -- | refers to a resource associated with a time interval that begins after the beginning of the time interval associated with the context resource, and ends before the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.23 - LinkRelationTypeIntervalcontains | - -- | refers to a resource associated with a time interval that begins after the end of the time interval associated with the context resource, or ends before the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.24 - LinkRelationTypeIntervaldisjoint | - -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.25 - LinkRelationTypeIntervalduring | - -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.26 - LinkRelationTypeIntervalequals | - -- | refers to a resource associated with a time interval that begins after the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.27 - LinkRelationTypeIntervalfinishedby | - -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and whose end coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.28 - LinkRelationTypeIntervalfinishes | - -- | refers to a resource associated with a time interval that begins before or is coincident with the beginning of the time interval associated with the context resource, and ends after or is coincident with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.29 - LinkRelationTypeIntervalin | - -- | refers to a resource associated with a time interval whose beginning coincides with the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.30 - LinkRelationTypeIntervalmeets | - -- | refers to a resource associated with a time interval whose end coincides with the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.31 - LinkRelationTypeIntervalmetby | - -- | refers to a resource associated with a time interval that begins before the beginning of the time interval associated with the context resource, and ends after the beginning of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.32 - LinkRelationTypeIntervaloverlappedby | - -- | refers to a resource associated with a time interval that begins before the end of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.33 - LinkRelationTypeIntervaloverlaps | - -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and ends before the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.34 - LinkRelationTypeIntervalstartedby | - -- | refers to a resource associated with a time interval whose beginning coincides with the beginning of the time interval associated with the context resource, and ends after the end of the time interval associated with the context resource [Time Ontology in OWL] section 4.2.35 - LinkRelationTypeIntervalstarts | - -- | The target IRI points to a resource that is a member of the collection represented by the context IRI. [RFC6573] - LinkRelationTypeItem | - -- | An IRI that refers to the furthest following resource in a series of resources. [RFC8288] This relation type registration did not indicate a reference. Originally requested by Mark Nottingham in December 2004. - LinkRelationTypeLast | - -- | Points to a resource containing the latest (e.g., current) version of the context. [RFC5829] - LinkRelationTypeLatest_version | - -- | Refers to a license associated with this context. [RFC4946] For implications of use in HTML, see: http://www.w3.org/TR/html5/links.html#link-type-license - LinkRelationTypeLicense | - -- | The link target of a link with the "linkset" relation type provides a set of links, including links in which the link context of the link participates. [RFC9264] - LinkRelationTypeLinkset | - -- | Refers to further information about the link's context, expressed as a LRDD ("Link-based Resource Descriptor Document") resource. See [RFC6415] for information about processing this relation type in host-meta documents. When used elsewhere, it refers to additional links and other metadata. Multiple instances indicate additional LRDD resources. LRDD resources MUST have an "application/xrd+xml" representation, and MAY have others. [RFC6415] - LinkRelationTypeLrdd | - -- | Links to a manifest file for the context. [Web App Manifest] - LinkRelationTypeManifest | - -- | Refers to a mask that can be applied to the icon for the context. [Creating Pinned Tab Icons] - LinkRelationTypeMask_icon | - -- | Refers to a feed of personalised media recommendations relevant to the link context. [https://wicg.github.io/media-feeds/#discovery-of-media-feeds] - LinkRelationTypeMedia_feed | - -- | The Target IRI points to a Memento, a fixed resource that will not change state anymore. [RFC7089] A Memento for an Original Resource is a resource that encapsulates a prior state of the Original Resource. - LinkRelationTypeMemento | - -- | Links to the context's Micropub endpoint. [Micropub] - LinkRelationTypeMicropub | - -- | Refers to a module that the user agent is to preemptively fetch and store for use in the current context. [HTML] - LinkRelationTypeModulepreload | - -- | Refers to a resource that can be used to monitor changes in an HTTP resource. [RFC5989] - LinkRelationTypeMonitor | - -- | Refers to a resource that can be used to monitor changes in a specified group of HTTP resources. [RFC5989] - LinkRelationTypeMonitor_group | - -- | Indicates that the link's context is a part of a series, and that the next in the series is the link target. [HTML] - LinkRelationTypeNext | - -- | Refers to the immediately following archive resource. [RFC5005] - LinkRelationTypeNext_archive | - -- | Indicates that the context's original author or publisher does not endorse the link target. [HTML] - LinkRelationTypeNofollow | - -- | Indicates that any newly created top-level browsing context which results from following the link will not be an auxiliary browsing context. [HTML] - LinkRelationTypeNoopener | - -- | Indicates that no referrer information is to be leaked when following the link. [HTML] - LinkRelationTypeNoreferrer | - -- | Indicates that any newly created top-level browsing context which results from following the link will be an auxiliary browsing context. [HTML] - LinkRelationTypeOpener | - -- | Refers to an OpenID Authentication server on which the context relies for an assertion that the end user controls an Identifier. [OpenID Authentication 2.0 - Final] - LinkRelationTypeOpenid2_local_id | - -- | Refers to a resource which accepts OpenID Authentication protocol messages for the context. [OpenID Authentication 2.0 - Final] - LinkRelationTypeOpenid2_provider | - -- | The Target IRI points to an Original Resource. [RFC7089] An Original Resource is a resource that exists or used to exist, and for which access to one of its prior states may be required. - LinkRelationTypeOriginal | - -- | Refers to a P3P privacy policy for the context. [The Platform for Privacy Preferences 1.0 (P3P1.0) Specification] - LinkRelationTypeP3pv1 | - -- | Indicates a resource where payment is accepted. [RFC8288] This relation type registration did not indicate a reference. Requested by Joshua Kinberg and Robert Sayre. It is meant as a general way to facilitate acts of payment, and thus this specification makes no assumptions on the type of payment or transaction protocol. Examples may include a web page where donations are accepted or where goods and services are available for purchase. rel="payment" is not intended to initiate an automated transaction. In Atom documents, a link element with a rel="payment" attribute may exist at the feed/channel level and/or the entry/item level. For example, a rel="payment" link at the feed/channel level may point to a "tip jar" URI, whereas an entry/ item containing a book review may include a rel="payment" link that points to the location where the book may be purchased through an online retailer. - LinkRelationTypePayment | - -- | Gives the address of the pingback resource for the link context. [Pingback 1.0] - LinkRelationTypePingback | - -- | Used to indicate an origin that will be used to fetch required resources for the link context. Initiating an early connection, which includes the DNS lookup, TCP handshake, and optional TLS negotiation, allows the user agent to mask the high latency costs of establishing a connection. [Resource Hints] - LinkRelationTypePreconnect | - -- | Points to a resource containing the predecessor version in the version history. [RFC5829] - LinkRelationTypePredecessor_version | - -- | The prefetch link relation type is used to identify a resource that might be required by the next navigation from the link context, and that the user agent ought to fetch, such that the user agent can deliver a faster response once the resource is requested in the future. [Resource Hints] - LinkRelationTypePrefetch | - -- | Refers to a resource that should be loaded early in the processing of the link's context, without blocking rendering. [Preload] Additional target attributes establish the detailed fetch properties of the link. - LinkRelationTypePreload | - -- | Used to identify a resource that might be required by the next navigation from the link context, and that the user agent ought to fetch and execute, such that the user agent can deliver a faster response once the resource is requested in the future. [Resource Hints] - LinkRelationTypePrerender | - -- | Indicates that the link's context is a part of a series, and that the previous in the series is the link target. [HTML] - LinkRelationTypePrev | - -- | Refers to a resource that provides a preview of the link's context. [RFC6903], section 3 - LinkRelationTypePreview | - -- | Refers to the previous resource in an ordered series of resources. Synonym for "prev". [HTML 4.01 Specification] - LinkRelationTypePrevious | - -- | Refers to the immediately preceding archive resource. [RFC5005] - LinkRelationTypePrev_archive | - -- | Refers to a privacy policy associated with the link's context. [RFC6903], section 4 - LinkRelationTypePrivacy_policy | - -- | Identifying that a resource representation conforms to a certain profile, without affecting the non-profile semantics of the resource representation. [RFC6906] Profile URIs are primarily intended to be used as identifiers, and thus clients SHOULD NOT indiscriminately access profile URIs. - LinkRelationTypeProfile | - -- | Links to a publication manifest. A manifest represents structured information about a publication, such as informative metadata, a list of resources, and a default reading order. [Publication Manifest] - LinkRelationTypePublication | - -- | Identifies a related resource. [RFC4287] - LinkRelationTypeRelated | - -- | Identifies the root of RESTCONF API as configured on this HTTP server. The "restconf" relation defines the root of the API defined in RFC8040. Subsequent revisions of RESTCONF will use alternate relation values to support protocol versioning. [RFC8040] - LinkRelationTypeRestconf | - -- | Identifies a resource that is a reply to the context of the link. [RFC4685] - LinkRelationTypeReplies | - -- | The resource identified by the link target provides an input value to an instance of a rule, where the resource which represents the rule instance is identified by the link context. [OCF Core Optional 2.2.0] - LinkRelationTypeRuleinput | - -- | Refers to a resource that can be used to search through the link's context and related resources. [OpenSearch] - LinkRelationTypeSearch | - -- | Refers to a section in a collection of resources. [HTML 4.01 Specification] - LinkRelationTypeSection | - -- | Conveys an identifier for the link's context. [RFC4287] - LinkRelationTypeSelf | - -- | Indicates a URI that can be used to retrieve a service document. [RFC5023] When used in an Atom document, this relation type specifies Atom Publishing Protocol service documents by default. Requested by James Snell. - LinkRelationTypeService | - -- | Identifies service description for the context that is primarily intended for consumption by machines. [RFC8631] - LinkRelationTypeService_desc | - -- | Identifies service documentation for the context that is primarily intended for human consumption. [RFC8631] - LinkRelationTypeService_doc | - -- | Identifies general metadata for the context that is primarily intended for consumption by machines. [RFC8631] - LinkRelationTypeService_meta | - -- | refers to a capability document that defines parameters or configuration requirements for automated peering and communication channel negotiation of the Session Initiation Protocol (SIP). [draft-engi-siptrunkingcapability-link] - LinkRelationTypeSiptrunkingcapability | - -- | Refers to a resource that is within a context that is sponsored (such as advertising or another compensation agreement). [Google Blog post 09-2019] - LinkRelationTypeSponsored | - -- | Refers to the first resource in a collection of resources. [HTML 4.01 Specification] - LinkRelationTypeStart | - -- | Identifies a resource that represents the context's status. [RFC8631] - LinkRelationTypeStatus | - -- | Refers to a stylesheet. [HTML] - LinkRelationTypeStylesheet | - -- | Refers to a resource serving as a subsection in a collection of resources. [HTML 4.01 Specification] - LinkRelationTypeSubsection | - -- | Points to a resource containing the successor version in the version history. [RFC5829] - LinkRelationTypeSuccessor_version | - -- | Identifies a resource that provides information about the context's retirement policy. [RFC8594] - LinkRelationTypeSunset | - -- | Gives a tag (identified by the given address) that applies to the current document. [HTML] - LinkRelationTypeTag | - -- | Refers to the terms of service associated with the link's context. [RFC6903], section 5 - LinkRelationTypeTerms_of_service | - -- | The Target IRI points to a TimeGate for an Original Resource. [RFC7089] A TimeGate for an Original Resource is a resource that is capable of datetime negotiation to support access to prior states of the Original Resource. - LinkRelationTypeTimegate | - -- | The Target IRI points to a TimeMap for an Original Resource. [RFC7089] A TimeMap for an Original Resource is a resource from which a list of URIs of Mementos of the Original Resource is available. - LinkRelationTypeTimemap | - -- | Refers to a resource identifying the abstract semantic type of which the link's context is considered to be an instance. [RFC6903], section 6 - LinkRelationTypeType | - -- | Refers to a resource that is within a context that is User Generated Content. [Google Blog post 09-2019] - LinkRelationTypeUgc | - -- | Refers to a parent document in a hierarchy of documents. [RFC8288] This relation type registration did not indicate a reference. Requested by Noah Slater. - LinkRelationTypeUp | - -- | Points to a resource containing the version history for the context. [RFC5829] - LinkRelationTypeVersion_history | - -- | Identifies a resource that is the source of the information in the link's context. [RFC4287] - LinkRelationTypeVia | - -- | Identifies a target URI that supports the Webmention protocol. This allows clients that mention a resource in some form of publishing process to contact that endpoint and inform it that this resource has been mentioned. [Webmention] This is a similar "Linkback" mechanism to the ones of Refback, Trackback, and Pingback. It uses a different protocol, though, and thus should be discoverable through its own link relation type. - LinkRelationTypeWebmention | - -- | Points to a working copy for this resource. [RFC5829] - LinkRelationTypeWorking_copy | - -- | Points to the versioned resource from which this working copy was obtained. [RFC5829] - LinkRelationTypeWorking_copy_of - deriving (Eq, Ord, Read, Show) - -_LinkRelationType = Core.Name "hydra.iana.linkrelations.LinkRelationType" - -_LinkRelationType_about = Core.Name "about" - -_LinkRelationType_acl = Core.Name "acl" - -_LinkRelationType_alternate = Core.Name "alternate" - -_LinkRelationType_amphtml = Core.Name "amphtml" - -_LinkRelationType_appendix = Core.Name "appendix" - -_LinkRelationType_apple_touch_icon = Core.Name "apple-touch-icon" - -_LinkRelationType_apple_touch_startup_image = Core.Name "apple-touch-startup-image" - -_LinkRelationType_archives = Core.Name "archives" - -_LinkRelationType_author = Core.Name "author" - -_LinkRelationType_blocked_by = Core.Name "blocked-by" - -_LinkRelationType_bookmark = Core.Name "bookmark" - -_LinkRelationType_canonical = Core.Name "canonical" - -_LinkRelationType_chapter = Core.Name "chapter" - -_LinkRelationType_cite_as = Core.Name "cite-as" - -_LinkRelationType_collection = Core.Name "collection" - -_LinkRelationType_contents = Core.Name "contents" - -_LinkRelationType_convertedfrom = Core.Name "convertedfrom" - -_LinkRelationType_copyright = Core.Name "copyright" - -_LinkRelationType_create_form = Core.Name "create-form" - -_LinkRelationType_current = Core.Name "current" - -_LinkRelationType_describedby = Core.Name "describedby" - -_LinkRelationType_describes = Core.Name "describes" - -_LinkRelationType_disclosure = Core.Name "disclosure" - -_LinkRelationType_dns_prefetch = Core.Name "dns-prefetch" - -_LinkRelationType_duplicate = Core.Name "duplicate" - -_LinkRelationType_edit = Core.Name "edit" - -_LinkRelationType_edit_form = Core.Name "edit-form" - -_LinkRelationType_edit_media = Core.Name "edit-media" - -_LinkRelationType_enclosure = Core.Name "enclosure" - -_LinkRelationType_external = Core.Name "external" - -_LinkRelationType_first = Core.Name "first" - -_LinkRelationType_glossary = Core.Name "glossary" - -_LinkRelationType_help = Core.Name "help" - -_LinkRelationType_hosts = Core.Name "hosts" - -_LinkRelationType_hub = Core.Name "hub" - -_LinkRelationType_icon = Core.Name "icon" - -_LinkRelationType_index = Core.Name "index" - -_LinkRelationType_intervalafter = Core.Name "intervalafter" - -_LinkRelationType_intervalbefore = Core.Name "intervalbefore" - -_LinkRelationType_intervalcontains = Core.Name "intervalcontains" - -_LinkRelationType_intervaldisjoint = Core.Name "intervaldisjoint" - -_LinkRelationType_intervalduring = Core.Name "intervalduring" - -_LinkRelationType_intervalequals = Core.Name "intervalequals" - -_LinkRelationType_intervalfinishedby = Core.Name "intervalfinishedby" - -_LinkRelationType_intervalfinishes = Core.Name "intervalfinishes" - -_LinkRelationType_intervalin = Core.Name "intervalin" - -_LinkRelationType_intervalmeets = Core.Name "intervalmeets" - -_LinkRelationType_intervalmetby = Core.Name "intervalmetby" - -_LinkRelationType_intervaloverlappedby = Core.Name "intervaloverlappedby" - -_LinkRelationType_intervaloverlaps = Core.Name "intervaloverlaps" - -_LinkRelationType_intervalstartedby = Core.Name "intervalstartedby" - -_LinkRelationType_intervalstarts = Core.Name "intervalstarts" - -_LinkRelationType_item = Core.Name "item" - -_LinkRelationType_last = Core.Name "last" - -_LinkRelationType_latest_version = Core.Name "latest-version" - -_LinkRelationType_license = Core.Name "license" - -_LinkRelationType_linkset = Core.Name "linkset" - -_LinkRelationType_lrdd = Core.Name "lrdd" - -_LinkRelationType_manifest = Core.Name "manifest" - -_LinkRelationType_mask_icon = Core.Name "mask-icon" - -_LinkRelationType_media_feed = Core.Name "media-feed" - -_LinkRelationType_memento = Core.Name "memento" - -_LinkRelationType_micropub = Core.Name "micropub" - -_LinkRelationType_modulepreload = Core.Name "modulepreload" - -_LinkRelationType_monitor = Core.Name "monitor" - -_LinkRelationType_monitor_group = Core.Name "monitor-group" - -_LinkRelationType_next = Core.Name "next" - -_LinkRelationType_next_archive = Core.Name "next-archive" - -_LinkRelationType_nofollow = Core.Name "nofollow" - -_LinkRelationType_noopener = Core.Name "noopener" - -_LinkRelationType_noreferrer = Core.Name "noreferrer" - -_LinkRelationType_opener = Core.Name "opener" - -_LinkRelationType_openid2_local_id = Core.Name "openid2.local_id" - -_LinkRelationType_openid2_provider = Core.Name "openid2.provider" - -_LinkRelationType_original = Core.Name "original" - -_LinkRelationType_p3pv1 = Core.Name "p3pv1" - -_LinkRelationType_payment = Core.Name "payment" - -_LinkRelationType_pingback = Core.Name "pingback" - -_LinkRelationType_preconnect = Core.Name "preconnect" - -_LinkRelationType_predecessor_version = Core.Name "predecessor-version" - -_LinkRelationType_prefetch = Core.Name "prefetch" - -_LinkRelationType_preload = Core.Name "preload" - -_LinkRelationType_prerender = Core.Name "prerender" - -_LinkRelationType_prev = Core.Name "prev" - -_LinkRelationType_preview = Core.Name "preview" - -_LinkRelationType_previous = Core.Name "previous" - -_LinkRelationType_prev_archive = Core.Name "prev-archive" - -_LinkRelationType_privacy_policy = Core.Name "privacy-policy" - -_LinkRelationType_profile = Core.Name "profile" - -_LinkRelationType_publication = Core.Name "publication" - -_LinkRelationType_related = Core.Name "related" - -_LinkRelationType_restconf = Core.Name "restconf" - -_LinkRelationType_replies = Core.Name "replies" - -_LinkRelationType_ruleinput = Core.Name "ruleinput" - -_LinkRelationType_search = Core.Name "search" - -_LinkRelationType_section = Core.Name "section" - -_LinkRelationType_self = Core.Name "self" - -_LinkRelationType_service = Core.Name "service" - -_LinkRelationType_service_desc = Core.Name "service-desc" - -_LinkRelationType_service_doc = Core.Name "service-doc" - -_LinkRelationType_service_meta = Core.Name "service-meta" - -_LinkRelationType_siptrunkingcapability = Core.Name "siptrunkingcapability" - -_LinkRelationType_sponsored = Core.Name "sponsored" - -_LinkRelationType_start = Core.Name "start" - -_LinkRelationType_status = Core.Name "status" - -_LinkRelationType_stylesheet = Core.Name "stylesheet" - -_LinkRelationType_subsection = Core.Name "subsection" - -_LinkRelationType_successor_version = Core.Name "successor-version" - -_LinkRelationType_sunset = Core.Name "sunset" - -_LinkRelationType_tag = Core.Name "tag" - -_LinkRelationType_terms_of_service = Core.Name "terms-of-service" - -_LinkRelationType_timegate = Core.Name "timegate" - -_LinkRelationType_timemap = Core.Name "timemap" - -_LinkRelationType_type = Core.Name "type" - -_LinkRelationType_ugc = Core.Name "ugc" - -_LinkRelationType_up = Core.Name "up" - -_LinkRelationType_version_history = Core.Name "version-history" - -_LinkRelationType_via = Core.Name "via" - -_LinkRelationType_webmention = Core.Name "webmention" - -_LinkRelationType_working_copy = Core.Name "working-copy" - -_LinkRelationType_working_copy_of = Core.Name "working-copy-of" diff --git a/src/main/haskell/Hydra/Json/Schema/Coder.hs b/src/main/haskell/Hydra/Json/Schema/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Json/Schema/Coder.hs +++ /dev/null @@ -1,286 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON Schema code generator: converts Hydra modules to JSON Schema documents - -module Hydra.Json.Schema.Coder where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Core as Core -import qualified Hydra.Dependencies as Dependencies -import qualified Hydra.Docs as Docs -import qualified Hydra.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Json.Schema.Model as SchemaModel -import qualified Hydra.Json.Schema.Serde as Serde -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -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.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Predicates as Predicates -import qualified Hydra.Print.Variants as PrintVariants -import qualified Hydra.Query as Query -import qualified Hydra.Reflect as Reflect -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variables as Variables -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M -import qualified Data.Set as S - --- | Construct JSON Schema documents from type definitions -constructModule :: t0 -> Graph.Graph -> t1 -> [Packaging.TypeDefinition] -> Either Errors.Error (M.Map String SchemaModel.Document) -constructModule cx g mod typeDefs = - - let typeBody = \td -> Core.typeSchemeBody (Packaging.typeDefinitionBody td) - typeMap = Maps.fromList (Lists.map (\td -> (Packaging.typeDefinitionName td, (typeBody td))) typeDefs) - in (Eithers.map (\ps -> Maps.fromList ps) (Eithers.mapList (\td -> typeDefToDocument cx g typeMap (Packaging.typeDefinitionName td) (typeBody td)) typeDefs)) - --- | Build a single-property record Schema for one branch of an Either oneOf -eitherBranch :: String -> [SchemaModel.Restriction] -> SchemaModel.Schema -eitherBranch label res = - SchemaModel.Schema [ - SchemaModel.RestrictionType (SchemaModel.TypeSingle SchemaModel.TypeNameObject), - (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.singleton (SchemaModel.Keyword label) (SchemaModel.Schema res)))), - (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired [ - SchemaModel.Keyword label])), - (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False)))] - --- | Encode a field type as a JSON Schema keyword-schema pair -encodeField :: t0 -> Graph.Graph -> Core.FieldType -> Either Errors.Error (SchemaModel.Keyword, SchemaModel.Schema) -encodeField cx g ft = - - let name = Core.fieldTypeName ft - typ = Core.fieldTypeType ft - in (Eithers.map (\res -> (SchemaModel.Keyword (Core.unName name), (SchemaModel.Schema res))) (typeToExpr cx g False typ)) - --- | Encode a Hydra name as a safe identifier string, replacing non-alphanumeric characters with underscores -encodeName :: Core.Name -> String -encodeName name = Formatting.nonAlnumToUnderscores (Core.unName name) - --- | Encode a named type as a list of JSON Schema restrictions with a title -encodeNamedType :: t0 -> Graph.Graph -> Core.Name -> Core.Type -> Either Errors.Error [SchemaModel.Restriction] -encodeNamedType cx g name typ = - Eithers.map (\res -> Lists.concat [ - [ - SchemaModel.RestrictionTitle (Core.unName name)], - res]) (typeToExpr cx g False (Strip.deannotateType typ)) - --- | Encode a record or union as a list of JSON Schema object restrictions; isUnion adds min/maxProperties=1 -encodeRecordOrUnion :: t0 -> Graph.Graph -> Bool -> Bool -> [Core.FieldType] -> Either Errors.Error [SchemaModel.Restriction] -encodeRecordOrUnion cx g optional isUnion fields = - Eithers.bind (Eithers.mapList (\ft -> encodeField cx g ft) fields) (\props -> - let objRes = [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.fromList props))] - reqs = - Lists.foldl (\acc -> \f -> Logic.ifElse (isRequiredField f) (Lists.concat2 acc [ - SchemaModel.Keyword (Core.unName (Core.fieldTypeName f))]) acc) [] fields - reqRes = - Logic.ifElse (Lists.isEmpty reqs) [] [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired reqs)] - addPropsRes = - [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False))] - cardRes = - Logic.ifElse isUnion [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionMinProperties 1), - (SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionMaxProperties 1))] [] - in (Right (Lists.concat [ - jsType optional SchemaModel.TypeNameObject, - objRes, - reqRes, - addPropsRes, - cardRes]))) - --- | Encode a union type, splitting unit-typed (simple) variants into a string-enum branch -encodeUnion :: t0 -> Graph.Graph -> Bool -> [Core.FieldType] -> Either Errors.Error [SchemaModel.Restriction] -encodeUnion cx g optional fields = - - let isSimple = \f -> Predicates.isUnitType (Strip.deannotateType (Core.fieldTypeType f)) - simple = Lists.filter isSimple fields - nonsimple = Lists.filter (\f -> Logic.not (isSimple f)) fields - in (Logic.ifElse (Lists.isEmpty simple) (encodeRecordOrUnion cx g optional True fields) (Eithers.bind (encodeRecordOrUnion cx g False True nonsimple) (\recRes -> - let names = Lists.map (\f -> Core.unName (Core.fieldTypeName f)) simple - simpleSchema = - SchemaModel.Schema [ - SchemaModel.RestrictionType (SchemaModel.TypeSingle SchemaModel.TypeNameString), - (SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionEnum (Lists.map (\n -> Model.ValueString n) names)))] - in (Right [ - SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionOneOf [ - SchemaModel.Schema recRes, - simpleSchema])])))) - --- | Determine whether a field is required (i.e., not optional/Maybe) -isRequiredField :: Core.FieldType -> Bool -isRequiredField ft = - - let typ = Core.fieldTypeType ft - in case (Strip.deannotateType typ) of - Core.TypeOptional _ -> False - _ -> True - --- | Build the JSON Schema type-restriction list for a type name, optionally widening to allow null -jsType :: Bool -> SchemaModel.TypeName -> [SchemaModel.Restriction] -jsType optional tname = - [ - SchemaModel.RestrictionType (Logic.ifElse optional (SchemaModel.TypeMultiple [ - tname, - SchemaModel.TypeNameNull]) (SchemaModel.TypeSingle tname))] - --- | Map a Hydra literal type to a JSON Schema type name -literalTypeName :: Core.LiteralType -> SchemaModel.TypeName -literalTypeName lt = - case lt of - Core.LiteralTypeBinary -> SchemaModel.TypeNameString - Core.LiteralTypeBoolean -> SchemaModel.TypeNameBoolean - Core.LiteralTypeFloat _ -> SchemaModel.TypeNameNumber - Core.LiteralTypeInteger _ -> SchemaModel.TypeNameInteger - Core.LiteralTypeString -> SchemaModel.TypeNameString - _ -> SchemaModel.TypeNameString - --- | Convert a Hydra module to a map from file path to JSON Schema document string -moduleToJsonSchema :: t0 -> [Packaging.Definition] -> t1 -> Graph.Graph -> Either Errors.Error (M.Map String String) -moduleToJsonSchema mod defs cx g = - - let partitioned = Environment.partitionDefinitions defs - typeDefs = Pairs.first partitioned - in (Eithers.map (\docs -> Maps.map (\doc -> Serde.jsonSchemaDocumentToString doc) docs) (constructModule cx g mod typeDefs)) - --- | Compute the JSON Schema output file path for a named type -nameToPath :: Core.Name -> String -nameToPath name = - - let qn = Names.qualifyName name - mns = Util.qualifiedNameModuleName qn - local = Util.qualifiedNameLocal qn - nsPart = Optionals.match mns "" (\ns -> Strings.concat2 (Packaging.unModuleName ns) ".") - in (Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "json") (Packaging.ModuleName (Strings.concat2 nsPart local))) - --- | Build the JSON Schema restriction list for a pair type -pairRestrictions :: Bool -> [SchemaModel.Restriction] -> [SchemaModel.Restriction] -> [SchemaModel.Restriction] -pairRestrictions optional firstRes secondRes = - Lists.concat [ - jsType optional SchemaModel.TypeNameObject, - [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionProperties (Maps.fromList [ - (SchemaModel.Keyword "first", (SchemaModel.Schema firstRes)), - (SchemaModel.Keyword "second", (SchemaModel.Schema secondRes))]))], - [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired [ - SchemaModel.Keyword "first", - (SchemaModel.Keyword "second")])], - [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False))]] - --- | Create a JSON Schema reference restriction for a named type -referenceRestriction :: Core.Name -> SchemaModel.Restriction -referenceRestriction name = - SchemaModel.RestrictionReference (SchemaModel.SchemaReference (Strings.concat [ - "#/$defs/", - (encodeName name)])) - --- | Walk the transitive named-type dependency closure of a root type through typeMap; the visited set guards against cycles in self-/mutually-recursive types -transitiveTypeDeps :: M.Map Core.Name Core.Type -> S.Set Core.Name -> Core.Type -> S.Set Core.Name -transitiveTypeDeps typeMap visited rootType = - - let directDeps = Dependencies.typeDependencyNames True rootType - step = - \acc -> \n -> Logic.ifElse (Sets.member n acc) acc ( - let acc1 = Sets.insert n acc - in (Optionals.match (Maps.lookup n typeMap) acc1 (\t -> transitiveTypeDeps typeMap acc1 t))) - in (Lists.foldl step visited (Sets.toList directDeps)) - --- | Build a JSON Schema document for a single named type, with $defs covering its transitive dependencies and short-name substitution applied -typeDefToDocument :: t0 -> Graph.Graph -> M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Either Errors.Error (String, SchemaModel.Document) -typeDefToDocument cx g typeMap rootName rootType = - - let depNames = Sets.toList (transitiveTypeDeps typeMap Sets.empty rootType) - allNames = Lists.concat2 [ - rootName] (Lists.filter (\n -> Logic.not (Equality.equal n rootName)) depNames) - allTypes = Lists.map (\n -> Optionals.withDefault (Core.TypeVariable n) (Maps.lookup n typeMap)) allNames - nameSubst = Dependencies.toShortNames allNames - types = Lists.map (\t -> Variables.substituteTypeVariables nameSubst t) allTypes - names = Lists.map (\n -> Optionals.withDefault n (Maps.lookup n nameSubst)) allNames - subRoot = Optionals.withDefault rootName (Maps.lookup rootName nameSubst) - pairs = Lists.zip names types - in (Eithers.bind (Eithers.mapList (\p -> typeToKeywordSchemaPair cx g (Pairs.first p) (Pairs.second p)) pairs) (\schemas -> Right ( - nameToPath rootName, - SchemaModel.Document { - SchemaModel.documentId = Nothing, - SchemaModel.documentDefinitions = (Just (Maps.fromList schemas)), - SchemaModel.documentRoot = (SchemaModel.Schema [ - referenceRestriction subRoot])}))) - --- | Encode a Hydra type as a list of JSON Schema restrictions -typeToExpr :: t0 -> Graph.Graph -> Bool -> Core.Type -> Either Errors.Error [SchemaModel.Restriction] -typeToExpr cx g optional typ = - case typ of - Core.TypeAnnotated _ -> Eithers.bind (typeToExpr cx g optional (Strip.deannotateType typ)) (\res -> Eithers.bind (Annotations.getTypeDescription cx g typ) (\mdesc -> Right (Lists.concat2 (Optionals.match mdesc [] (\d -> [ - SchemaModel.RestrictionDescription d])) res))) - Core.TypeApplication v0 -> typeToExpr cx g optional (Core.applicationTypeFunction v0) - Core.TypeEither v0 -> - let lt = Core.eitherTypeLeft v0 - rt = Core.eitherTypeRight v0 - in (Eithers.bind (typeToExpr cx g False lt) (\leftRes -> Eithers.bind (typeToExpr cx g False rt) (\rightRes -> Right [ - SchemaModel.RestrictionMultiple (SchemaModel.MultipleRestrictionOneOf [ - eitherBranch "left" leftRes, - (eitherBranch "right" rightRes)])]))) - Core.TypeForall v0 -> typeToExpr cx g optional (Core.forallTypeBody v0) - Core.TypeList v0 -> Eithers.bind (typeToExpr cx g False v0) (\els -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameArray) [ - SchemaModel.RestrictionArray (SchemaModel.ArrayRestrictionItems (SchemaModel.ItemsSameItems (SchemaModel.Schema els)))])) - Core.TypeLiteral v0 -> Right (jsType optional (literalTypeName v0)) - Core.TypeMap v0 -> - let vt = Core.mapTypeValues v0 - in (Eithers.bind (typeToExpr cx g False vt) (\vRes -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameObject) [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsSchema (SchemaModel.Schema vRes)))]))) - Core.TypeOptional v0 -> typeToExpr cx g True v0 - Core.TypePair v0 -> - let ft = Core.pairTypeFirst v0 - st = Core.pairTypeSecond v0 - in (Eithers.bind (typeToExpr cx g False ft) (\firstRes -> Eithers.bind (typeToExpr cx g False st) (\secondRes -> Right (pairRestrictions optional firstRes secondRes)))) - Core.TypeRecord v0 -> encodeRecordOrUnion cx g optional False v0 - Core.TypeSet v0 -> Eithers.bind (typeToExpr cx g False v0) (\els -> Right (Lists.concat2 (jsType optional SchemaModel.TypeNameArray) [ - SchemaModel.RestrictionArray (SchemaModel.ArrayRestrictionItems (SchemaModel.ItemsSameItems (SchemaModel.Schema els)))])) - Core.TypeUnion v0 -> encodeUnion cx g optional v0 - Core.TypeVariable v0 -> Right [ - referenceRestriction v0] - Core.TypeWrap v0 -> typeToExpr cx g optional v0 - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "JSON Schema: unsupported type variant: " (PrintVariants.typeVariant (Reflect.typeVariant typ))))) - --- | Build a (Keyword, Schema) pair for a named type, used as a $defs entry -typeToKeywordSchemaPair :: t0 -> Graph.Graph -> Core.Name -> Core.Type -> Either Errors.Error (SchemaModel.Keyword, SchemaModel.Schema) -typeToKeywordSchemaPair cx g name typ = - Eithers.map (\res -> (SchemaModel.Keyword (encodeName name), (SchemaModel.Schema res))) (encodeNamedType cx g name typ) diff --git a/src/main/haskell/Hydra/Json/Schema/Language.hs b/src/main/haskell/Hydra/Json/Schema/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Json/Schema/Language.hs +++ /dev/null @@ -1,98 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for JSON Schema - -module Hydra.Json.Schema.Language 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.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Reflect as Reflect -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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Language constraints for JSON Schema -jsonSchemaLanguage :: Coders.Language -jsonSchemaLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.json.schema"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "json")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = Sets.fromList [ - Core.FloatTypeFloat64] - integerTypes = Sets.fromList [ - Core.IntegerTypeBigint] - termVariants = Sets.fromList Reflect.termVariants - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantVariable, - Variants.TypeVariantWrap] - typePredicate = \_ -> True diff --git a/src/main/haskell/Hydra/Json/Schema/Model.hs b/src/main/haskell/Hydra/Json/Schema/Model.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Json/Schema/Model.hs +++ /dev/null @@ -1,280 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for JSON Schema. Based on https://cswr.github.io/JsonSchema/spec/grammar - -module Hydra.Json.Schema.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Whether additional array items beyond those explicitly typed are permitted, and if so, their schema -data AdditionalItems = - AdditionalItemsAny Bool | - AdditionalItemsSchema Schema - deriving (Eq, Ord, Read, Show) - -_AdditionalItems = Core.Name "hydra.json.schema.model.AdditionalItems" - -_AdditionalItems_any = Core.Name "any" - -_AdditionalItems_schema = Core.Name "schema" - --- | A restriction on array-typed values: items, additionalItems, minItems, maxItems, or uniqueItems -data ArrayRestriction = - ArrayRestrictionItems Items | - ArrayRestrictionAdditionalItems AdditionalItems | - ArrayRestrictionMinItems Int | - ArrayRestrictionMaxItems Int | - ArrayRestrictionUniqueItems Bool - deriving (Eq, Ord, Read, Show) - -_ArrayRestriction = Core.Name "hydra.json.schema.model.ArrayRestriction" - -_ArrayRestriction_items = Core.Name "items" - -_ArrayRestriction_additionalItems = Core.Name "additionalItems" - -_ArrayRestriction_minItems = Core.Name "minItems" - -_ArrayRestriction_maxItems = Core.Name "maxItems" - -_ArrayRestriction_uniqueItems = Core.Name "uniqueItems" - --- | A JSON Schema document: an optional id, optional local definitions, and a root schema -data Document = - Document { - documentId :: (Maybe String), - documentDefinitions :: (Maybe (M.Map Keyword Schema)), - documentRoot :: Schema} - deriving (Eq, Ord, Read, Show) - -_Document = Core.Name "hydra.json.schema.model.Document" - -_Document_id = Core.Name "id" - -_Document_definitions = Core.Name "definitions" - -_Document_root = Core.Name "root" - --- | The schema(s) for array items: either a single schema shared by all items, or one schema per item -data Items = - ItemsSameItems Schema | - ItemsVarItems [Schema] - deriving (Eq, Ord, Read, Show) - -_Items = Core.Name "hydra.json.schema.model.Items" - -_Items_sameItems = Core.Name "sameItems" - -_Items_varItems = Core.Name "varItems" - --- | A property name used as a key in a JSON Schema keyword-to-schema map -newtype Keyword = - Keyword { - unKeyword :: String} - deriving (Eq, Ord, Read, Show) - -_Keyword = Core.Name "hydra.json.schema.model.Keyword" - --- | A numeric bound with a flag indicating whether the bound itself is excluded -data Limit = - Limit { - limitValue :: Int, - limitExclusive :: Bool} - deriving (Eq, Ord, Read, Show) - -_Limit = Core.Name "hydra.json.schema.model.Limit" - -_Limit_value = Core.Name "value" - -_Limit_exclusive = Core.Name "exclusive" - --- | A restriction combining multiple schemas: allOf, anyOf, oneOf, not, or enum -data MultipleRestriction = - MultipleRestrictionAllOf [Schema] | - MultipleRestrictionAnyOf [Schema] | - MultipleRestrictionOneOf [Schema] | - MultipleRestrictionNot Schema | - MultipleRestrictionEnum [Model.Value] - deriving (Eq, Ord, Read, Show) - -_MultipleRestriction = Core.Name "hydra.json.schema.model.MultipleRestriction" - -_MultipleRestriction_allOf = Core.Name "allOf" - -_MultipleRestriction_anyOf = Core.Name "anyOf" - -_MultipleRestriction_oneOf = Core.Name "oneOf" - -_MultipleRestriction_not = Core.Name "not" - -_MultipleRestriction_enum = Core.Name "enum" - --- | A restriction on numeric-typed values: a minimum, a maximum, or a multipleOf constraint -data NumericRestriction = - NumericRestrictionMinimum Limit | - NumericRestrictionMaximum Limit | - NumericRestrictionMultipleOf Int - deriving (Eq, Ord, Read, Show) - -_NumericRestriction = Core.Name "hydra.json.schema.model.NumericRestriction" - -_NumericRestriction_minimum = Core.Name "minimum" - -_NumericRestriction_maximum = Core.Name "maximum" - -_NumericRestriction_multipleOf = Core.Name "multipleOf" - --- | A restriction on object-typed values: properties, additionalProperties, required, and related keywords -data ObjectRestriction = - ObjectRestrictionProperties (M.Map Keyword Schema) | - ObjectRestrictionAdditionalProperties AdditionalItems | - ObjectRestrictionRequired [Keyword] | - ObjectRestrictionMinProperties Int | - ObjectRestrictionMaxProperties Int | - ObjectRestrictionDependencies (M.Map Keyword SchemaOrArray) | - ObjectRestrictionPatternProperties (M.Map RegularExpression Schema) - deriving (Eq, Ord, Read, Show) - -_ObjectRestriction = Core.Name "hydra.json.schema.model.ObjectRestriction" - -_ObjectRestriction_properties = Core.Name "properties" - -_ObjectRestriction_additionalProperties = Core.Name "additionalProperties" - -_ObjectRestriction_required = Core.Name "required" - -_ObjectRestriction_minProperties = Core.Name "minProperties" - -_ObjectRestriction_maxProperties = Core.Name "maxProperties" - -_ObjectRestriction_dependencies = Core.Name "dependencies" - -_ObjectRestriction_patternProperties = Core.Name "patternProperties" - --- | A regular expression pattern, as used by the pattern and patternProperties keywords -newtype RegularExpression = - RegularExpression { - unRegularExpression :: String} - deriving (Eq, Ord, Read, Show) - -_RegularExpression = Core.Name "hydra.json.schema.model.RegularExpression" - --- | A single JSON Schema restriction: a type, value restriction, reference, title, or description -data Restriction = - RestrictionType Type | - RestrictionString StringRestriction | - RestrictionNumber NumericRestriction | - RestrictionArray ArrayRestriction | - RestrictionObject ObjectRestriction | - RestrictionMultiple MultipleRestriction | - RestrictionReference SchemaReference | - RestrictionTitle String | - RestrictionDescription String - deriving (Eq, Ord, Read, Show) - -_Restriction = Core.Name "hydra.json.schema.model.Restriction" - -_Restriction_type = Core.Name "type" - -_Restriction_string = Core.Name "string" - -_Restriction_number = Core.Name "number" - -_Restriction_array = Core.Name "array" - -_Restriction_object = Core.Name "object" - -_Restriction_multiple = Core.Name "multiple" - -_Restriction_reference = Core.Name "reference" - -_Restriction_title = Core.Name "title" - -_Restriction_description = Core.Name "description" - --- | A JSON schema: a non-empty list of restrictions that a conforming value must satisfy -newtype Schema = - Schema { - unSchema :: [Restriction]} - deriving (Eq, Ord, Read, Show) - -_Schema = Core.Name "hydra.json.schema.model.Schema" - --- | A dependency value: either a schema, or a list of required keyword names -data SchemaOrArray = - SchemaOrArraySchema Schema | - SchemaOrArrayArray [Keyword] - deriving (Eq, Ord, Read, Show) - -_SchemaOrArray = Core.Name "hydra.json.schema.model.SchemaOrArray" - -_SchemaOrArray_schema = Core.Name "schema" - -_SchemaOrArray_array = Core.Name "array" - --- | A reference to another schema by URI -newtype SchemaReference = - SchemaReference { - unSchemaReference :: String} - deriving (Eq, Ord, Read, Show) - -_SchemaReference = Core.Name "hydra.json.schema.model.SchemaReference" - --- | A restriction on string-typed values: minLength, maxLength, or pattern -data StringRestriction = - StringRestrictionMinLength Int | - StringRestrictionMaxLength Int | - StringRestrictionPattern RegularExpression - deriving (Eq, Ord, Read, Show) - -_StringRestriction = Core.Name "hydra.json.schema.model.StringRestriction" - -_StringRestriction_minLength = Core.Name "minLength" - -_StringRestriction_maxLength = Core.Name "maxLength" - -_StringRestriction_pattern = Core.Name "pattern" - --- | A type restriction: a single type name, or a list of alternative type names -data Type = - TypeSingle TypeName | - TypeMultiple [TypeName] - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.json.schema.model.Type" - -_Type_single = Core.Name "single" - -_Type_multiple = Core.Name "multiple" - --- | The name of a JSON Schema primitive type -data TypeName = - TypeNameString | - TypeNameInteger | - TypeNameNumber | - TypeNameBoolean | - TypeNameNull | - TypeNameArray | - TypeNameObject - deriving (Eq, Ord, Read, Show) - -_TypeName = Core.Name "hydra.json.schema.model.TypeName" - -_TypeName_string = Core.Name "string" - -_TypeName_integer = Core.Name "integer" - -_TypeName_number = Core.Name "number" - -_TypeName_boolean = Core.Name "boolean" - -_TypeName_null = Core.Name "null" - -_TypeName_array = Core.Name "array" - -_TypeName_object = Core.Name "object" diff --git a/src/main/haskell/Hydra/Json/Schema/Serde.hs b/src/main/haskell/Hydra/Json/Schema/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Json/Schema/Serde.hs +++ /dev/null @@ -1,384 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Serialization functions for converting JSON Schema documents to JSON values - -module Hydra.Json.Schema.Serde 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.Json.Schema.Model as SchemaModel -import qualified Hydra.Json.Writer as Writer -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Encode additional items as a JSON value -additionalItemsToExpr :: SchemaModel.AdditionalItems -> Model.Value -additionalItemsToExpr ai = - case ai of - SchemaModel.AdditionalItemsAny v0 -> Model.ValueBoolean v0 - SchemaModel.AdditionalItemsSchema v0 -> schemaToExpr v0 - --- | Encode an array restriction as a key-value pair -arrayRestrictionToExpr :: SchemaModel.ArrayRestriction -> (String, Model.Value) -arrayRestrictionToExpr r = - case r of - SchemaModel.ArrayRestrictionItems v0 -> itemsToExpr v0 - SchemaModel.ArrayRestrictionAdditionalItems v0 -> (keyAdditionalItems, (additionalItemsToExpr v0)) - SchemaModel.ArrayRestrictionMinItems v0 -> (keyMinItems, (integerToExpr v0)) - SchemaModel.ArrayRestrictionMaxItems v0 -> (keyMaxItems, (integerToExpr v0)) - SchemaModel.ArrayRestrictionUniqueItems v0 -> (keyUniqueItems, (Model.ValueBoolean v0)) - --- | Extract a name-keyed map from a JSON object value (field order is dropped) -fromObject :: Model.Value -> M.Map String Model.Value -fromObject v = - case v of - Model.ValueObject v0 -> Maps.fromList v0 - --- | Encode an integer as a JSON number value -integerToExpr :: Int -> Model.Value -integerToExpr n = Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint n)) - --- | Encode items as a key-value pair -itemsToExpr :: SchemaModel.Items -> (String, Model.Value) -itemsToExpr items = - ( - keyItems, - case items of - SchemaModel.ItemsSameItems v0 -> schemaToExpr v0 - SchemaModel.ItemsVarItems v0 -> Model.ValueArray (Lists.map schemaToExpr v0)) - --- | Convert a JSON Schema document to a JSON value -jsonSchemaDocumentToJsonValue :: SchemaModel.Document -> Model.Value -jsonSchemaDocumentToJsonValue doc = - - let mid = SchemaModel.documentId doc - mdefs = SchemaModel.documentDefinitions doc - root = SchemaModel.documentRoot doc - schemaMap = fromObject (schemaToExpr root) - restMap = - fromObject (toObject [ - (keyId, (Optionals.map (\i -> Model.ValueString i) mid)), - (keySchema, (Optionals.given (Model.ValueString "http://json-schema.org/2020-12/schema"))), - ( - keyDefinitions, - (Optionals.map (\mp -> Model.ValueObject (Lists.map (\p -> - let k = Pairs.first p - schema = Pairs.second p - in (SchemaModel.unKeyword k, (schemaToExpr schema))) (Maps.toList mp))) mdefs))]) - in (Model.ValueObject (Maps.toList (Maps.union schemaMap restMap))) - --- | Convert a JSON Schema document to a JSON string -jsonSchemaDocumentToString :: SchemaModel.Document -> String -jsonSchemaDocumentToString doc = Writer.printJson (jsonSchemaDocumentToJsonValue doc) - --- | The JSON Schema "additionalItems" keyword -keyAdditionalItems :: String -keyAdditionalItems = "additionalItems" - --- | The JSON Schema "additionalProperties" keyword -keyAdditionalProperties :: String -keyAdditionalProperties = "additionalProperties" - --- | The JSON Schema "allOf" keyword -keyAllOf :: String -keyAllOf = "allOf" - --- | The JSON Schema "anyOf" keyword -keyAnyOf :: String -keyAnyOf = "anyOf" - --- | The JSON Schema "$defs" keyword, used for reusable schema definitions -keyDefinitions :: String -keyDefinitions = "$defs" - --- | The JSON Schema "dependencies" keyword -keyDependencies :: String -keyDependencies = "dependencies" - --- | The JSON Schema "description" keyword -keyDescription :: String -keyDescription = "description" - --- | The JSON Schema "enum" keyword -keyEnum :: String -keyEnum = "enum" - --- | The JSON Schema "exclusiveMaximum" keyword -keyExclusiveMaximum :: String -keyExclusiveMaximum = "exclusiveMaximum" - --- | The JSON Schema "exclusiveMinimum" keyword -keyExclusiveMinimum :: String -keyExclusiveMinimum = "exclusiveMinimum" - --- | The JSON Schema "$id" keyword, identifying the schema -keyId :: String -keyId = "$id" - --- | The JSON Schema "items" keyword -keyItems :: String -keyItems = "items" - --- | The JSON Schema "label" keyword -keyLabel :: String -keyLabel = "label" - --- | The JSON Schema "maxItems" keyword -keyMaxItems :: String -keyMaxItems = "maxItems" - --- | The JSON Schema "maxLength" keyword -keyMaxLength :: String -keyMaxLength = "maxLength" - --- | The JSON Schema "maxProperties" keyword -keyMaxProperties :: String -keyMaxProperties = "maxProperties" - --- | The JSON Schema "maximum" keyword -keyMaximum :: String -keyMaximum = "maximum" - --- | The JSON Schema "minItems" keyword -keyMinItems :: String -keyMinItems = "minItems" - --- | The JSON Schema "minLength" keyword -keyMinLength :: String -keyMinLength = "minLength" - --- | The JSON Schema "minProperties" keyword -keyMinProperties :: String -keyMinProperties = "minProperties" - --- | The JSON Schema "minimum" keyword -keyMinimum :: String -keyMinimum = "minimum" - --- | The JSON Schema "multipleOf" keyword -keyMultipleOf :: String -keyMultipleOf = "multipleOf" - --- | The JSON Schema "not" keyword -keyNot :: String -keyNot = "not" - --- | The JSON Schema "oneOf" keyword -keyOneOf :: String -keyOneOf = "oneOf" - --- | The JSON Schema "pattern" keyword -keyPattern :: String -keyPattern = "pattern" - --- | The JSON Schema "patternProperties" keyword -keyPatternProperties :: String -keyPatternProperties = "patternProperties" - --- | The JSON Schema "properties" keyword -keyProperties :: String -keyProperties = "properties" - --- | The JSON Schema "$ref" keyword, used for schema references -keyRef :: String -keyRef = "$ref" - --- | The JSON Schema "required" keyword -keyRequired :: String -keyRequired = "required" - --- | The JSON Schema "$schema" keyword, identifying the schema dialect -keySchema :: String -keySchema = "$schema" - --- | The JSON Schema "title" keyword -keyTitle :: String -keyTitle = "title" - --- | The JSON Schema "type" keyword -keyType :: String -keyType = "type" - --- | The JSON Schema "uniqueItems" keyword -keyUniqueItems :: String -keyUniqueItems = "uniqueItems" - --- | Encode a keyword-schema-or-array pair as a key-value pair -keywordSchemaOrArrayToExpr :: (SchemaModel.Keyword, SchemaModel.SchemaOrArray) -> (String, Model.Value) -keywordSchemaOrArrayToExpr p = - - let k = Pairs.first p - s = Pairs.second p - in (SchemaModel.unKeyword k, (schemaOrArrayToExpr s)) - --- | Encode a keyword as a JSON string value -keywordToExpr :: SchemaModel.Keyword -> Model.Value -keywordToExpr k = Model.ValueString (SchemaModel.unKeyword k) - --- | Encode a multiple restriction as a key-value pair -multipleRestrictionToExpr :: SchemaModel.MultipleRestriction -> (String, Model.Value) -multipleRestrictionToExpr r = - case r of - SchemaModel.MultipleRestrictionAllOf v0 -> (keyAllOf, (Model.ValueArray (Lists.map schemaToExpr v0))) - SchemaModel.MultipleRestrictionAnyOf v0 -> (keyAnyOf, (Model.ValueArray (Lists.map schemaToExpr v0))) - SchemaModel.MultipleRestrictionOneOf v0 -> (keyOneOf, (Model.ValueArray (Lists.map schemaToExpr v0))) - SchemaModel.MultipleRestrictionNot v0 -> (keyNot, (schemaToExpr v0)) - SchemaModel.MultipleRestrictionEnum v0 -> (keyEnum, (Model.ValueArray v0)) - --- | Encode a numeric restriction as a list of key-value pairs -numericRestrictionToExpr :: SchemaModel.NumericRestriction -> [(String, Model.Value)] -numericRestrictionToExpr r = - case r of - SchemaModel.NumericRestrictionMinimum v0 -> - let value = SchemaModel.limitValue v0 - excl = SchemaModel.limitExclusive v0 - in (Lists.concat [ - [ - (keyMinimum, (integerToExpr value))], - (Logic.ifElse excl [ - (keyExclusiveMinimum, (Model.ValueBoolean True))] [])]) - SchemaModel.NumericRestrictionMaximum v0 -> - let value = SchemaModel.limitValue v0 - excl = SchemaModel.limitExclusive v0 - in (Lists.concat [ - [ - (keyMaximum, (integerToExpr value))], - (Logic.ifElse excl [ - (keyExclusiveMaximum, (Model.ValueBoolean True))] [])]) - SchemaModel.NumericRestrictionMultipleOf v0 -> [ - (keyMultipleOf, (integerToExpr v0))] - --- | Encode an object restriction as a key-value pair -objectRestrictionToExpr :: SchemaModel.ObjectRestriction -> (String, Model.Value) -objectRestrictionToExpr r = - case r of - SchemaModel.ObjectRestrictionProperties v0 -> (keyProperties, (Model.ValueObject (Lists.map propertyToExpr (Maps.toList v0)))) - SchemaModel.ObjectRestrictionAdditionalProperties v0 -> (keyAdditionalProperties, (additionalItemsToExpr v0)) - SchemaModel.ObjectRestrictionRequired v0 -> (keyRequired, (Model.ValueArray (Lists.map keywordToExpr v0))) - SchemaModel.ObjectRestrictionMinProperties v0 -> (keyMinProperties, (integerToExpr v0)) - SchemaModel.ObjectRestrictionMaxProperties v0 -> (keyMaxProperties, (integerToExpr v0)) - SchemaModel.ObjectRestrictionDependencies v0 -> (keyDependencies, (Model.ValueObject (Lists.map keywordSchemaOrArrayToExpr (Maps.toList v0)))) - SchemaModel.ObjectRestrictionPatternProperties v0 -> (keyPatternProperties, (Model.ValueObject (Lists.map patternPropertyToExpr (Maps.toList v0)))) - --- | Encode a pattern property pair as a key-value pair -patternPropertyToExpr :: (SchemaModel.RegularExpression, SchemaModel.Schema) -> (String, Model.Value) -patternPropertyToExpr p = - - let pat = Pairs.first p - s = Pairs.second p - in (SchemaModel.unRegularExpression pat, (schemaToExpr s)) - --- | Encode a property pair as a key-value pair -propertyToExpr :: (SchemaModel.Keyword, SchemaModel.Schema) -> (String, Model.Value) -propertyToExpr p = - - let k = Pairs.first p - s = Pairs.second p - in (SchemaModel.unKeyword k, (schemaToExpr s)) - --- | Encode a restriction as a list of key-value pairs -restrictionToExpr :: SchemaModel.Restriction -> [(String, Model.Value)] -restrictionToExpr r = - case r of - SchemaModel.RestrictionType v0 -> [ - (keyType, (typeToExpr v0))] - SchemaModel.RestrictionString v0 -> [ - stringRestrictionToExpr v0] - SchemaModel.RestrictionNumber v0 -> numericRestrictionToExpr v0 - SchemaModel.RestrictionArray v0 -> [ - arrayRestrictionToExpr v0] - SchemaModel.RestrictionObject v0 -> [ - objectRestrictionToExpr v0] - SchemaModel.RestrictionMultiple v0 -> [ - multipleRestrictionToExpr v0] - SchemaModel.RestrictionReference v0 -> [ - (keyRef, (schemaReferenceToExpr v0))] - SchemaModel.RestrictionTitle v0 -> [ - (keyTitle, (Model.ValueString v0))] - SchemaModel.RestrictionDescription v0 -> [ - (keyDescription, (Model.ValueString v0))] - --- | Encode a schema or array as a JSON value -schemaOrArrayToExpr :: SchemaModel.SchemaOrArray -> Model.Value -schemaOrArrayToExpr soa = - case soa of - SchemaModel.SchemaOrArraySchema v0 -> schemaToExpr v0 - SchemaModel.SchemaOrArrayArray v0 -> Model.ValueArray (Lists.map keywordToExpr v0) - --- | Encode a schema reference as a JSON string value -schemaReferenceToExpr :: SchemaModel.SchemaReference -> Model.Value -schemaReferenceToExpr sr = Model.ValueString (SchemaModel.unSchemaReference sr) - --- | Encode a schema as a JSON object value -schemaToExpr :: SchemaModel.Schema -> Model.Value -schemaToExpr s = Model.ValueObject (Lists.concat (Lists.map restrictionToExpr (SchemaModel.unSchema s))) - --- | Encode a string restriction as a key-value pair -stringRestrictionToExpr :: SchemaModel.StringRestriction -> (String, Model.Value) -stringRestrictionToExpr r = - case r of - SchemaModel.StringRestrictionMaxLength v0 -> (keyMaxLength, (Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint v0)))) - SchemaModel.StringRestrictionMinLength v0 -> (keyMinLength, (Model.ValueNumber (Literals.bigintToDecimal (Literals.int32ToBigint v0)))) - SchemaModel.StringRestrictionPattern v0 -> (keyPattern, (Model.ValueString (SchemaModel.unRegularExpression v0))) - --- | Construct a JSON object from a list of optional key-value pairs, filtering out Nothing values -toObject :: [(String, (Maybe Model.Value))] -> Model.Value -toObject pairs = - Model.ValueObject (Optionals.givens (Lists.map (\p -> - let k = Pairs.first p - mv = Pairs.second p - in (Optionals.map (\v -> (k, v)) mv)) pairs)) - --- | Encode a type name as a JSON string value -typeNameToExpr :: SchemaModel.TypeName -> Model.Value -typeNameToExpr t = - case t of - SchemaModel.TypeNameString -> Model.ValueString "string" - SchemaModel.TypeNameInteger -> Model.ValueString "integer" - SchemaModel.TypeNameNumber -> Model.ValueString "number" - SchemaModel.TypeNameBoolean -> Model.ValueString "boolean" - SchemaModel.TypeNameNull -> Model.ValueString "null" - SchemaModel.TypeNameArray -> Model.ValueString "array" - SchemaModel.TypeNameObject -> Model.ValueString "object" - --- | Encode a type as a JSON value -typeToExpr :: SchemaModel.Type -> Model.Value -typeToExpr t = - case t of - SchemaModel.TypeSingle v0 -> typeNameToExpr v0 - SchemaModel.TypeMultiple v0 -> Model.ValueArray (Lists.map typeNameToExpr v0) diff --git a/src/main/haskell/Hydra/Kusto/Kql.hs b/src/main/haskell/Hydra/Kusto/Kql.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Kusto/Kql.hs +++ /dev/null @@ -1,737 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A partial KQL (Kusto Query Language) model, based on examples from the documentation. Not normative. - -module Hydra.Kusto.Kql where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Int as I - --- | A 'between' range test on an expression, optionally negated -data BetweenExpression = - BetweenExpression { - betweenExpressionNot :: Bool, - betweenExpressionExpression :: Expression, - betweenExpressionLowerBound :: Expression, - betweenExpressionUpperBound :: Expression} - deriving (Eq, Ord, Read, Show) - -_BetweenExpression = Core.Name "hydra.kusto.kql.BetweenExpression" - -_BetweenExpression_not = Core.Name "not" - -_BetweenExpression_expression = Core.Name "expression" - -_BetweenExpression_lowerBound = Core.Name "lowerBound" - -_BetweenExpression_upperBound = Core.Name "upperBound" - --- | A binary operator expression, combining a left and right operand -data BinaryExpression = - BinaryExpression { - binaryExpressionLeft :: Expression, - binaryExpressionOperator :: BinaryOperator, - binaryExpressionRight :: Expression} - deriving (Eq, Ord, Read, Show) - -_BinaryExpression = Core.Name "hydra.kusto.kql.BinaryExpression" - -_BinaryExpression_left = Core.Name "left" - -_BinaryExpression_operator = Core.Name "operator" - -_BinaryExpression_right = Core.Name "right" - --- | A binary comparison or arithmetic operator used in KQL expressions -data BinaryOperator = - BinaryOperatorCaseInsensitiveEqual | - BinaryOperatorContains | - BinaryOperatorDivide | - BinaryOperatorEndsWith | - BinaryOperatorEqual | - BinaryOperatorGreater | - BinaryOperatorGreaterOrEqual | - BinaryOperatorHas | - BinaryOperatorHasPrefix | - BinaryOperatorHasSuffix | - BinaryOperatorLess | - BinaryOperatorLessOrEqual | - BinaryOperatorMatchesRegex | - BinaryOperatorMinus | - BinaryOperatorNotEqual | - BinaryOperatorPlus | - BinaryOperatorStartsWith | - BinaryOperatorTimes - deriving (Eq, Ord, Read, Show) - -_BinaryOperator = Core.Name "hydra.kusto.kql.BinaryOperator" - -_BinaryOperator_caseInsensitiveEqual = Core.Name "caseInsensitiveEqual" - -_BinaryOperator_contains = Core.Name "contains" - -_BinaryOperator_divide = Core.Name "divide" - -_BinaryOperator_endsWith = Core.Name "endsWith" - -_BinaryOperator_equal = Core.Name "equal" - -_BinaryOperator_greater = Core.Name "greater" - -_BinaryOperator_greaterOrEqual = Core.Name "greaterOrEqual" - -_BinaryOperator_has = Core.Name "has" - -_BinaryOperator_hasPrefix = Core.Name "hasPrefix" - -_BinaryOperator_hasSuffix = Core.Name "hasSuffix" - -_BinaryOperator_less = Core.Name "less" - -_BinaryOperator_lessOrEqual = Core.Name "lessOrEqual" - -_BinaryOperator_matchesRegex = Core.Name "matchesRegex" - -_BinaryOperator_minus = Core.Name "minus" - -_BinaryOperator_notEqual = Core.Name "notEqual" - -_BinaryOperator_plus = Core.Name "plus" - -_BinaryOperator_startsWith = Core.Name "startsWith" - -_BinaryOperator_times = Core.Name "times" - --- | One of the built-in scalar or aggregation functions supported by KQL -data BuiltInFunction = - BuiltInFunctionAgo | - BuiltInFunctionBin | - BuiltInFunctionCount | - BuiltInFunctionDcount | - BuiltInFunctionEndofday | - BuiltInFunctionExtract | - BuiltInFunctionFormat_datetime | - BuiltInFunctionMaterialize | - BuiltInFunctionNow | - BuiltInFunctionRange | - BuiltInFunctionStartofday | - BuiltInFunctionStrcat | - BuiltInFunctionTodynamic - deriving (Eq, Ord, Read, Show) - -_BuiltInFunction = Core.Name "hydra.kusto.kql.BuiltInFunction" - -_BuiltInFunction_ago = Core.Name "ago" - -_BuiltInFunction_bin = Core.Name "bin" - -_BuiltInFunction_count = Core.Name "count" - -_BuiltInFunction_dcount = Core.Name "dcount" - -_BuiltInFunction_endofday = Core.Name "endofday" - -_BuiltInFunction_extract = Core.Name "extract" - -_BuiltInFunction_format_datetime = Core.Name "format_datetime" - -_BuiltInFunction_materialize = Core.Name "materialize" - -_BuiltInFunction_now = Core.Name "now" - -_BuiltInFunction_range = Core.Name "range" - -_BuiltInFunction_startofday = Core.Name "startofday" - -_BuiltInFunction_strcat = Core.Name "strcat" - -_BuiltInFunction_todynamic = Core.Name "todynamic" - --- | An association between a column and an alternate (renamed) column name -data ColumnAlias = - ColumnAlias { - columnAliasColumn :: ColumnName, - columnAliasAlias :: ColumnName} - deriving (Eq, Ord, Read, Show) - -_ColumnAlias = Core.Name "hydra.kusto.kql.ColumnAlias" - -_ColumnAlias_column = Core.Name "column" - -_ColumnAlias_alias = Core.Name "alias" - --- | An assignment of a computed expression to a column -data ColumnAssignment = - ColumnAssignment { - columnAssignmentColumn :: ColumnName, - columnAssignmentExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_ColumnAssignment = Core.Name "hydra.kusto.kql.ColumnAssignment" - -_ColumnAssignment_column = Core.Name "column" - -_ColumnAssignment_expression = Core.Name "expression" - --- | The name of a table column -newtype ColumnName = - ColumnName { - unColumnName :: String} - deriving (Eq, Ord, Read, Show) - -_ColumnName = Core.Name "hydra.kusto.kql.ColumnName" - --- | A selection of either all columns, or a single named column -data Columns = - ColumnsAll | - ColumnsSingle ColumnName - deriving (Eq, Ord, Read, Show) - -_Columns = Core.Name "hydra.kusto.kql.Columns" - -_Columns_all = Core.Name "all" - -_Columns_single = Core.Name "single" - --- | A tabular operator, applied in sequence within a pipeline expression -data Command = - CommandCount | - -- | See https://learn.microsoft.com/en-us/azure/data-explorer/kusto/query/distinct-operator - CommandDistinct [ColumnName] | - CommandExtend [ColumnAssignment] | - CommandJoin JoinCommand | - CommandLimit Int | - CommandMvexpand ColumnName | - CommandOrderBy [SortBy] | - CommandParse ParseCommand | - CommandPrint PrintCommand | - CommandProject [Projection] | - CommandProjectAway [ColumnName] | - CommandProjectRename [ColumnAlias] | - CommandRender String | - CommandSearch SearchCommand | - CommandSortBy [SortBy] | - CommandSummarize SummarizeCommand | - -- | Limit a search to a specified number of results - CommandTake Int | - CommandTop TopCommand | - CommandUnion UnionCommand | - CommandWhere Expression - deriving (Eq, Ord, Read, Show) - -_Command = Core.Name "hydra.kusto.kql.Command" - -_Command_count = Core.Name "count" - -_Command_distinct = Core.Name "distinct" - -_Command_extend = Core.Name "extend" - -_Command_join = Core.Name "join" - -_Command_limit = Core.Name "limit" - -_Command_mvexpand = Core.Name "mvexpand" - -_Command_orderBy = Core.Name "orderBy" - -_Command_parse = Core.Name "parse" - -_Command_print = Core.Name "print" - -_Command_project = Core.Name "project" - -_Command_projectAway = Core.Name "projectAway" - -_Command_projectRename = Core.Name "projectRename" - -_Command_render = Core.Name "render" - -_Command_search = Core.Name "search" - -_Command_sortBy = Core.Name "sortBy" - -_Command_summarize = Core.Name "summarize" - -_Command_take = Core.Name "take" - -_Command_top = Core.Name "top" - -_Command_union = Core.Name "union" - -_Command_where = Core.Name "where" - --- | A KQL datetime literal -newtype Datetime = - Datetime { - unDatetime :: String} - deriving (Eq, Ord, Read, Show) - -_Datetime = Core.Name "hydra.kusto.kql.Datetime" - --- | A duration (timespan) literal, expressed as a value and a unit -data Duration = - Duration { - durationValue :: Int, - durationUnit :: DurationUnit} - deriving (Eq, Ord, Read, Show) - -_Duration = Core.Name "hydra.kusto.kql.Duration" - -_Duration_value = Core.Name "value" - -_Duration_unit = Core.Name "unit" - --- | The unit of measure of a Duration value -data DurationUnit = - DurationUnitSecond | - DurationUnitMinute | - DurationUnitHour - deriving (Eq, Ord, Read, Show) - -_DurationUnit = Core.Name "hydra.kusto.kql.DurationUnit" - -_DurationUnit_second = Core.Name "second" - -_DurationUnit_minute = Core.Name "minute" - -_DurationUnit_hour = Core.Name "hour" - --- | A KQL scalar expression -data Expression = - ExpressionAnd [Expression] | - ExpressionAny | - ExpressionBetween BetweenExpression | - ExpressionBinary BinaryExpression | - ExpressionBraces Expression | - ExpressionColumn ColumnName | - ExpressionDataset TableName | - ExpressionIndex IndexExpression | - ExpressionList [Expression] | - ExpressionLiteral Literal | - ExpressionOr [Expression] | - ExpressionParentheses Expression | - ExpressionProperty PropertyExpression | - ExpressionUnary UnaryExpression - deriving (Eq, Ord, Read, Show) - -_Expression = Core.Name "hydra.kusto.kql.Expression" - -_Expression_and = Core.Name "and" - -_Expression_any = Core.Name "any" - -_Expression_between = Core.Name "between" - -_Expression_binary = Core.Name "binary" - -_Expression_braces = Core.Name "braces" - -_Expression_column = Core.Name "column" - -_Expression_dataset = Core.Name "dataset" - -_Expression_index = Core.Name "index" - -_Expression_list = Core.Name "list" - -_Expression_literal = Core.Name "literal" - -_Expression_or = Core.Name "or" - -_Expression_parentheses = Core.Name "parentheses" - -_Expression_property = Core.Name "property" - -_Expression_unary = Core.Name "unary" - --- | A reference to either a built-in or a user-defined function -data Function = - FunctionBuiltIn BuiltInFunction | - FunctionCustom FunctionName - deriving (Eq, Ord, Read, Show) - -_Function = Core.Name "hydra.kusto.kql.Function" - -_Function_builtIn = Core.Name "builtIn" - -_Function_custom = Core.Name "custom" - --- | An invocation of a function with a list of argument expressions -data FunctionExpression = - FunctionExpression { - functionExpressionFunction :: Function, - functionExpressionArguments :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_FunctionExpression = Core.Name "hydra.kusto.kql.FunctionExpression" - -_FunctionExpression_function = Core.Name "function" - -_FunctionExpression_arguments = Core.Name "arguments" - --- | The name of a user-defined function -newtype FunctionName = - FunctionName { - unFunctionName :: String} - deriving (Eq, Ord, Read, Show) - -_FunctionName = Core.Name "hydra.kusto.kql.FunctionName" - --- | An indexing operation applied to an expression, e.g. array or property access -data IndexExpression = - IndexExpression { - indexExpressionExpression :: Expression, - indexExpressionIndex :: String} - deriving (Eq, Ord, Read, Show) - -_IndexExpression = Core.Name "hydra.kusto.kql.IndexExpression" - -_IndexExpression_expression = Core.Name "expression" - -_IndexExpression_index = Core.Name "index" - --- | A 'join' operator combining rows from the current and a second tabular expression -data JoinCommand = - JoinCommand { - joinCommandKind :: JoinKind, - joinCommandExpression :: TableName, - joinCommandOn :: Expression} - deriving (Eq, Ord, Read, Show) - -_JoinCommand = Core.Name "hydra.kusto.kql.JoinCommand" - -_JoinCommand_kind = Core.Name "kind" - -_JoinCommand_expression = Core.Name "expression" - -_JoinCommand_on = Core.Name "on" - --- | The kind of join to perform, e.g. inner, left outer, or left semi/anti -data JoinKind = - JoinKindLeftouter | - JoinKindLeftsemi | - JoinKindLeftanti | - JoinKindFullouter | - JoinKindInner | - JoinKindInnerunique | - JoinKindRightouter | - JoinKindRightsemi | - JoinKindRightanti - deriving (Eq, Ord, Read, Show) - -_JoinKind = Core.Name "hydra.kusto.kql.JoinKind" - -_JoinKind_leftouter = Core.Name "leftouter" - -_JoinKind_leftsemi = Core.Name "leftsemi" - -_JoinKind_leftanti = Core.Name "leftanti" - -_JoinKind_fullouter = Core.Name "fullouter" - -_JoinKind_inner = Core.Name "inner" - -_JoinKind_innerunique = Core.Name "innerunique" - -_JoinKind_rightouter = Core.Name "rightouter" - -_JoinKind_rightsemi = Core.Name "rightsemi" - -_JoinKind_rightanti = Core.Name "rightanti" - --- | A key-value pair extracted by a 'parse' command -data KeyValuePair = - KeyValuePair { - keyValuePairKey :: String, - keyValuePairValue :: Expression} - deriving (Eq, Ord, Read, Show) - -_KeyValuePair = Core.Name "hydra.kusto.kql.KeyValuePair" - -_KeyValuePair_key = Core.Name "key" - -_KeyValuePair_value = Core.Name "value" - --- | A single 'let' binding of a name to an expression -data LetBinding = - LetBinding { - letBindingName :: ColumnName, - letBindingExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_LetBinding = Core.Name "hydra.kusto.kql.LetBinding" - -_LetBinding_name = Core.Name "name" - -_LetBinding_expression = Core.Name "expression" - --- | A sequence of 'let' bindings followed by a tabular expression that may reference them -data LetExpression = - LetExpression { - letExpressionBindings :: [LetBinding], - letExpressionExpression :: TabularExpression} - deriving (Eq, Ord, Read, Show) - -_LetExpression = Core.Name "hydra.kusto.kql.LetExpression" - -_LetExpression_bindings = Core.Name "bindings" - -_LetExpression_expression = Core.Name "expression" - --- | A literal value in a KQL expression -data Literal = - LiteralDuration Duration | - LiteralDatetime Datetime | - LiteralString String | - LiteralInt Int | - LiteralLong I.Int64 | - LiteralDouble Double | - LiteralBoolean Bool - deriving (Eq, Ord, Read, Show) - -_Literal = Core.Name "hydra.kusto.kql.Literal" - -_Literal_duration = Core.Name "duration" - -_Literal_datetime = Core.Name "datetime" - -_Literal_string = Core.Name "string" - -_Literal_int = Core.Name "int" - -_Literal_long = Core.Name "long" - -_Literal_double = Core.Name "double" - -_Literal_boolean = Core.Name "boolean" - --- | The sort direction for an 'order by' or 'sort by' clause -data Order = - OrderAscending | - OrderDescending - deriving (Eq, Ord, Read, Show) - -_Order = Core.Name "hydra.kusto.kql.Order" - -_Order_ascending = Core.Name "ascending" - -_Order_descending = Core.Name "descending" - --- | A named parameter with a literal value, e.g. for a union operator -data Parameter = - Parameter { - parameterKey :: String, - parameterValue :: Literal} - deriving (Eq, Ord, Read, Show) - -_Parameter = Core.Name "hydra.kusto.kql.Parameter" - -_Parameter_key = Core.Name "key" - -_Parameter_value = Core.Name "value" - --- | A 'parse' command that extracts key-value pairs from a column into new columns -data ParseCommand = - ParseCommand { - parseCommandColumn :: ColumnName, - parseCommandPairs :: [KeyValuePair]} - deriving (Eq, Ord, Read, Show) - -_ParseCommand = Core.Name "hydra.kusto.kql.ParseCommand" - -_ParseCommand_column = Core.Name "column" - -_ParseCommand_pairs = Core.Name "pairs" - --- | A pipe ('|')-separated sequence of tabular expressions -newtype PipelineExpression = - PipelineExpression { - unPipelineExpression :: [TabularExpression]} - deriving (Eq, Ord, Read, Show) - -_PipelineExpression = Core.Name "hydra.kusto.kql.PipelineExpression" - --- | A 'print' command that outputs the value of an expression, optionally naming a column -data PrintCommand = - PrintCommand { - printCommandColumn :: (Maybe ColumnName), - printCommandExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_PrintCommand = Core.Name "hydra.kusto.kql.PrintCommand" - -_PrintCommand_column = Core.Name "column" - -_PrintCommand_expression = Core.Name "expression" - --- | An expression to project as a column, with an optional alias, used by a 'project' command -data Projection = - Projection { - projectionExpression :: Expression, - projectionAlias :: (Maybe ColumnName)} - deriving (Eq, Ord, Read, Show) - -_Projection = Core.Name "hydra.kusto.kql.Projection" - -_Projection_expression = Core.Name "expression" - -_Projection_alias = Core.Name "alias" - --- | A dotted property access on an expression, e.g. 'x.property' -data PropertyExpression = - PropertyExpression { - propertyExpressionExpression :: Expression, - propertyExpressionProperty :: String} - deriving (Eq, Ord, Read, Show) - -_PropertyExpression = Core.Name "hydra.kusto.kql.PropertyExpression" - -_PropertyExpression_expression = Core.Name "expression" - -_PropertyExpression_property = Core.Name "property" - --- | A complete KQL query, consisting of a single tabular expression -newtype Query = - Query { - unQuery :: TabularExpression} - deriving (Eq, Ord, Read, Show) - -_Query = Core.Name "hydra.kusto.kql.Query" - --- | Search across all datasets and columns or, if provided, specific datasets and/or columns -data SearchCommand = - SearchCommand { - searchCommandDatasets :: [TableName], - searchCommandPattern :: Expression} - deriving (Eq, Ord, Read, Show) - -_SearchCommand = Core.Name "hydra.kusto.kql.SearchCommand" - -_SearchCommand_datasets = Core.Name "datasets" - -_SearchCommand_pattern = Core.Name "pattern" - --- | A single sort key with an optional sort order, used by 'order by'/'sort by' -data SortBy = - SortBy { - sortByColumn :: ColumnName, - sortByOrder :: (Maybe Order)} - deriving (Eq, Ord, Read, Show) - -_SortBy = Core.Name "hydra.kusto.kql.SortBy" - -_SortBy_column = Core.Name "column" - -_SortBy_order = Core.Name "order" - --- | A 'summarize' command that computes aggregate columns, optionally grouped by other columns -data SummarizeCommand = - SummarizeCommand { - summarizeCommandColumns :: [ColumnAssignment], - summarizeCommandBy :: [ColumnName]} - deriving (Eq, Ord, Read, Show) - -_SummarizeCommand = Core.Name "hydra.kusto.kql.SummarizeCommand" - -_SummarizeCommand_columns = Core.Name "columns" - -_SummarizeCommand_by = Core.Name "by" - --- | The name of a table or dataset -newtype TableName = - TableName { - unTableName :: String} - deriving (Eq, Ord, Read, Show) - -_TableName = Core.Name "hydra.kusto.kql.TableName" - --- | An expression which produces a table: a command, pipeline, let expression, or table reference -data TabularExpression = - TabularExpressionCommand Command | - TabularExpressionPipeline PipelineExpression | - TabularExpressionLet LetExpression | - TabularExpressionTable TableName - deriving (Eq, Ord, Read, Show) - -_TabularExpression = Core.Name "hydra.kusto.kql.TabularExpression" - -_TabularExpression_command = Core.Name "command" - -_TabularExpression_pipeline = Core.Name "pipeline" - -_TabularExpression_let = Core.Name "let" - -_TabularExpression_table = Core.Name "table" - --- | A 'top' command that returns the first N rows sorted by the given columns -data TopCommand = - TopCommand { - topCommandCount :: Int, - topCommandSort :: [SortBy]} - deriving (Eq, Ord, Read, Show) - -_TopCommand = Core.Name "hydra.kusto.kql.TopCommand" - -_TopCommand_count = Core.Name "count" - -_TopCommand_sort = Core.Name "sort" - --- | A unary operator expression applied to a single operand -data UnaryExpression = - UnaryExpression { - unaryExpressionOperator :: UnaryOperator, - unaryExpressionExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_UnaryExpression = Core.Name "hydra.kusto.kql.UnaryExpression" - -_UnaryExpression_operator = Core.Name "operator" - -_UnaryExpression_expression = Core.Name "expression" - --- | A unary operator used in KQL expressions -data UnaryOperator = - UnaryOperatorNot - deriving (Eq, Ord, Read, Show) - -_UnaryOperator = Core.Name "hydra.kusto.kql.UnaryOperator" - -_UnaryOperator_not = Core.Name "not" - --- | A 'union' command that combines rows from multiple tables -data UnionCommand = - UnionCommand { - unionCommandParameters :: [Parameter], - unionCommandKind :: (Maybe UnionKind), - unionCommandWithSource :: (Maybe ColumnName), - unionCommandIsFuzzy :: (Maybe Bool), - unionCommandTables :: [TableName]} - deriving (Eq, Ord, Read, Show) - -_UnionCommand = Core.Name "hydra.kusto.kql.UnionCommand" - -_UnionCommand_parameters = Core.Name "parameters" - -_UnionCommand_kind = Core.Name "kind" - -_UnionCommand_withSource = Core.Name "withSource" - -_UnionCommand_isFuzzy = Core.Name "isFuzzy" - -_UnionCommand_tables = Core.Name "tables" - --- | Whether a union preserves only common columns (inner) or all columns (outer) -data UnionKind = - UnionKindInner | - UnionKindOuter - deriving (Eq, Ord, Read, Show) - -_UnionKind = Core.Name "hydra.kusto.kql.UnionKind" - -_UnionKind_inner = Core.Name "inner" - -_UnionKind_outer = Core.Name "outer" diff --git a/src/main/haskell/Hydra/Osv/Schema.hs b/src/main/haskell/Hydra/Osv/Schema.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Osv/Schema.hs +++ /dev/null @@ -1,266 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | See https://ossf.github.io/osv-schema - -module Hydra.Osv.Schema where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A person or entity credited with discovering, fixing, or reporting a vulnerability -data Credited = - Credited { - creditedName :: String, - creditedContact :: (Maybe [Url])} - deriving (Eq, Ord, Read, Show) - -_Credited = Core.Name "hydra.osv.schema.Credited" - -_Credited_name = Core.Name "name" - -_Credited_contact = Core.Name "contact" - --- | One of a limited set of defined ecosystems, currently Go, npm, OSS-Fuzz, PyPI, RubyGems, crates.io, Packagist, Maven, NuGet, Linux, Debian, Hex, Android, GitHub Actions, or Pub -newtype Ecosystem = - Ecosystem { - unEcosystem :: String} - deriving (Eq, Ord, Read, Show) - -_Ecosystem = Core.Name "hydra.osv.schema.Ecosystem" - --- | A single OSV vulnerability entry -data Entry = - Entry { - -- | The default value is '1.0.0', matching version 1.0 of the OSV Schema - entrySchemaVersion :: (Maybe OsvVersion), - entryId :: Id, - entryModified :: Timestamp, - entryPublished :: (Maybe Timestamp), - entryWithdrawn :: (Maybe Timestamp), - entryAliases :: (Maybe [Id]), - entryRelated :: (Maybe [Id]), - entrySummary :: (Maybe String), - entryDetails :: (Maybe Markdown), - entrySeverity :: (Maybe [Severity]), - entryAffected :: (Maybe [PackageVersions]), - entryReferences :: (Maybe [Reference]), - entryCredits :: (Maybe [Credited])} - deriving (Eq, Ord, Read, Show) - -_Entry = Core.Name "hydra.osv.schema.Entry" - -_Entry_schemaVersion = Core.Name "schemaVersion" - -_Entry_id = Core.Name "id" - -_Entry_modified = Core.Name "modified" - -_Entry_published = Core.Name "published" - -_Entry_withdrawn = Core.Name "withdrawn" - -_Entry_aliases = Core.Name "aliases" - -_Entry_related = Core.Name "related" - -_Entry_summary = Core.Name "summary" - -_Entry_details = Core.Name "details" - -_Entry_severity = Core.Name "severity" - -_Entry_affected = Core.Name "affected" - -_Entry_references = Core.Name "references" - -_Entry_credits = Core.Name "credits" - --- | A version event marking a point in a range where a vulnerability's status changes -data Event = - EventIntroduced VersionOrZero | - EventFixed Version | - EventLastAffected Version | - EventLimit VersionOrStar - deriving (Eq, Ord, Read, Show) - -_Event = Core.Name "hydra.osv.schema.Event" - -_Event_introduced = Core.Name "introduced" - -_Event_fixed = Core.Name "fixed" - -_Event_lastAffected = Core.Name "lastAffected" - -_Event_limit = Core.Name "limit" - --- | A string of the format -, where DB names the database and ENTRYID is in the format used by the database. For example: OSV-2020-111, CVE-2021-3114, or GHSA-vp9c-fpxx-744v -newtype Id = - Id { - unId :: String} - deriving (Eq, Ord, Read, Show) - -_Id = Core.Name "hydra.osv.schema.Id" - --- | CommonMark markdown text -newtype Markdown = - Markdown { - unMarkdown :: String} - deriving (Eq, Ord, Read, Show) - -_Markdown = Core.Name "hydra.osv.schema.Markdown" - --- | A string which follows the SemVer 2.0.0 format, with no leading 'v' prefix -newtype OsvVersion = - OsvVersion { - unOsvVersion :: String} - deriving (Eq, Ord, Read, Show) - -_OsvVersion = Core.Name "hydra.osv.schema.OsvVersion" - --- | The identity of a software package within a given ecosystem -data Package = - Package { - packageEcosystem :: Ecosystem, - packageName :: String, - packagePurl :: (Maybe Url)} - deriving (Eq, Ord, Read, Show) - -_Package = Core.Name "hydra.osv.schema.Package" - -_Package_ecosystem = Core.Name "ecosystem" - -_Package_name = Core.Name "name" - -_Package_purl = Core.Name "purl" - --- | The package affected by a vulnerability, along with its affected version ranges and versions -data PackageVersions = - PackageVersions { - packageVersionsPackage :: Package, - packageVersionsRanges :: (Maybe [VersionRange]), - packageVersionsVersions :: (Maybe [Version])} - deriving (Eq, Ord, Read, Show) - -_PackageVersions = Core.Name "hydra.osv.schema.PackageVersions" - -_PackageVersions_package = Core.Name "package" - -_PackageVersions_ranges = Core.Name "ranges" - -_PackageVersions_versions = Core.Name "versions" - --- | A link to additional information about a vulnerability, together with its type -data Reference = - Reference { - referenceType :: ReferenceType, - referenceUrl :: Url} - deriving (Eq, Ord, Read, Show) - -_Reference = Core.Name "hydra.osv.schema.Reference" - -_Reference_type = Core.Name "type" - -_Reference_url = Core.Name "url" - --- | One of ADVISORY, ARTICLE, REPORT, FIX, GIT, PACKAGE, EVIDENCE, or WEB -newtype ReferenceType = - ReferenceType { - unReferenceType :: String} - deriving (Eq, Ord, Read, Show) - -_ReferenceType = Core.Name "hydra.osv.schema.ReferenceType" - --- | A severity score for a vulnerability, together with the scoring type used -data Severity = - Severity { - severityType :: SeverityType, - severityScore :: SeverityScore} - deriving (Eq, Ord, Read, Show) - -_Severity = Core.Name "hydra.osv.schema.Severity" - -_Severity_type = Core.Name "type" - -_Severity_score = Core.Name "score" - --- | The severity score value, formatted according to its severity type -newtype SeverityScore = - SeverityScore { - unSeverityScore :: String} - deriving (Eq, Ord, Read, Show) - -_SeverityScore = Core.Name "hydra.osv.schema.SeverityScore" - --- | The value CVSS_V3, or future supported types -newtype SeverityType = - SeverityType { - unSeverityType :: String} - deriving (Eq, Ord, Read, Show) - -_SeverityType = Core.Name "hydra.osv.schema.SeverityType" - --- | An RFC3339-formatted timestamp in UTC (ending in 'Z') -newtype Timestamp = - Timestamp { - unTimestamp :: String} - deriving (Eq, Ord, Read, Show) - -_Timestamp = Core.Name "hydra.osv.schema.Timestamp" - --- | A URL string -newtype Url = - Url { - unUrl :: String} - deriving (Eq, Ord, Read, Show) - -_Url = Core.Name "hydra.osv.schema.Url" - --- | A version number in an ecosystem-specific format -newtype Version = - Version { - unVersion :: String} - deriving (Eq, Ord, Read, Show) - -_Version = Core.Name "hydra.osv.schema.Version" - --- | An ecosystem-specific version number, or the string '*' representing infinity -newtype VersionOrStar = - VersionOrStar { - unVersionOrStar :: String} - deriving (Eq, Ord, Read, Show) - -_VersionOrStar = Core.Name "hydra.osv.schema.VersionOrStar" - --- | An ecosystem-specific version number, or the string '0' representing a version that sorts before any other version -newtype VersionOrZero = - VersionOrZero { - unVersionOrZero :: String} - deriving (Eq, Ord, Read, Show) - -_VersionOrZero = Core.Name "hydra.osv.schema.VersionOrZero" - --- | A range of affected versions, expressed as a type and an ordered list of events -data VersionRange = - VersionRange { - versionRangeType :: VersionType, - versionRangeRepo :: (Maybe Url), - versionRangeEvents :: [Event]} - deriving (Eq, Ord, Read, Show) - -_VersionRange = Core.Name "hydra.osv.schema.VersionRange" - -_VersionRange_type = Core.Name "type" - -_VersionRange_repo = Core.Name "repo" - -_VersionRange_events = Core.Name "events" - --- | One of the values 'SEMVER', 'ECOSYSTEM', or 'GIT -newtype VersionType = - VersionType { - unVersionType :: String} - deriving (Eq, Ord, Read, Show) - -_VersionType = Core.Name "hydra.osv.schema.VersionType" diff --git a/src/main/haskell/Hydra/Parquet/Format.hs b/src/main/haskell/Hydra/Parquet/Format.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Parquet/Format.hs +++ /dev/null @@ -1,990 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for the Parquet format. Based on the Thrift-based specification at: --- | https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift - -module Hydra.Parquet.Format where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.ByteString as B -import qualified Data.Int as I - --- | AES GCM CTR mode encryption parameters -data AesGcmCtrV1 = - AesGcmCtrV1 { - -- | AAD prefix - aesGcmCtrV1AadPrefix :: (Maybe B.ByteString), - -- | Unique file identifier part of AAD suffix - aesGcmCtrV1AadFileUnique :: (Maybe B.ByteString), - -- | In files encrypted with AAD prefix without storing it, readers must supply the prefix - aesGcmCtrV1SupplyAadPrefix :: (Maybe Bool)} - deriving (Eq, Ord, Read, Show) - -_AesGcmCtrV1 = Core.Name "hydra.parquet.format.AesGcmCtrV1" - -_AesGcmCtrV1_aadPrefix = Core.Name "aadPrefix" - -_AesGcmCtrV1_aadFileUnique = Core.Name "aadFileUnique" - -_AesGcmCtrV1_supplyAadPrefix = Core.Name "supplyAadPrefix" - --- | AES GCM mode encryption parameters -data AesGcmV1 = - AesGcmV1 { - -- | AAD prefix - aesGcmV1AadPrefix :: (Maybe B.ByteString), - -- | Unique file identifier part of AAD suffix - aesGcmV1AadFileUnique :: (Maybe B.ByteString), - -- | In files encrypted with AAD prefix without storing it, readers must supply the prefix - aesGcmV1SupplyAadPrefix :: (Maybe Bool)} - deriving (Eq, Ord, Read, Show) - -_AesGcmV1 = Core.Name "hydra.parquet.format.AesGcmV1" - -_AesGcmV1_aadPrefix = Core.Name "aadPrefix" - -_AesGcmV1_aadFileUnique = Core.Name "aadFileUnique" - -_AesGcmV1_supplyAadPrefix = Core.Name "supplyAadPrefix" - --- | The algorithm used in Bloom filter. -data BloomFilterAlgorithm = - -- | Block-based Bloom filter. - BloomFilterAlgorithmBlock - deriving (Eq, Ord, Read, Show) - -_BloomFilterAlgorithm = Core.Name "hydra.parquet.format.BloomFilterAlgorithm" - -_BloomFilterAlgorithm_block = Core.Name "block" - --- | The compression used in the Bloom filter. -data BloomFilterCompression = - BloomFilterCompressionUncompressed - deriving (Eq, Ord, Read, Show) - -_BloomFilterCompression = Core.Name "hydra.parquet.format.BloomFilterCompression" - -_BloomFilterCompression_uncompressed = Core.Name "uncompressed" - --- | The hash function used in Bloom filter. This function takes the hash of a column value using plain encoding. -data BloomFilterHash = - -- | xxHash Strategy. - BloomFilterHashXxhash - deriving (Eq, Ord, Read, Show) - -_BloomFilterHash = Core.Name "hydra.parquet.format.BloomFilterHash" - -_BloomFilterHash_xxhash = Core.Name "xxhash" - --- | Bloom filter header is stored at beginning of Bloom filter data of each column and followed by its bitset. -data BloomFilterHeader = - BloomFilterHeader { - -- | The size of bitset in bytes - bloomFilterHeaderNumBytes :: Int, - -- | The algorithm for setting bits. - bloomFilterHeaderAlgorithm :: BloomFilterAlgorithm, - -- | The hash function used for Bloom filter. - bloomFilterHeaderHash :: BloomFilterHash, - -- | The compression used in the Bloom filter - bloomFilterHeaderCompression :: BloomFilterCompression} - deriving (Eq, Ord, Read, Show) - -_BloomFilterHeader = Core.Name "hydra.parquet.format.BloomFilterHeader" - -_BloomFilterHeader_numBytes = Core.Name "numBytes" - -_BloomFilterHeader_algorithm = Core.Name "algorithm" - -_BloomFilterHeader_hash = Core.Name "hash" - -_BloomFilterHeader_compression = Core.Name "compression" - --- | Enum to annotate whether lists of min/max elements inside ColumnIndex are ordered and if so, in which direction. -data BoundaryOrder = - BoundaryOrderUnordered | - BoundaryOrderAscending | - BoundaryOrderDescending - deriving (Eq, Ord, Read, Show) - -_BoundaryOrder = Core.Name "hydra.parquet.format.BoundaryOrder" - -_BoundaryOrder_unordered = Core.Name "unordered" - -_BoundaryOrder_ascending = Core.Name "ascending" - -_BoundaryOrder_descending = Core.Name "descending" - --- | Metadata and location of a single column's data within a row group -data ColumnChunk = - ColumnChunk { - -- | File where column data is stored. If not set, assumed to be same file as metadata. This path is relative to the current file. - columnChunkFilePath :: (Maybe String), - -- | Byte offset in file_path to the ColumnMetaData - columnChunkFileOffset :: I.Int64, - -- | Column metadata for this chunk. This is the same content as what is at file_path/file_offset. Having it here has it replicated in the file metadata. - columnChunkMetaData :: (Maybe ColumnMetaData), - -- | File offset of ColumnChunk's OffsetIndex - columnChunkOffsetIndexOffset :: (Maybe I.Int64), - -- | Size of ColumnChunk's OffsetIndex, in bytes - columnChunkOffsetIndexLength :: (Maybe Int), - -- | File offset of ColumnChunk's ColumnIndex - columnChunkColumnIndexOffset :: (Maybe I.Int64), - -- | Size of ColumnChunk's ColumnIndex, in bytes - columnChunkColumnIndexLength :: (Maybe Int), - -- | Crypto metadata of encrypted columns - columnChunkCryptoMetadata :: (Maybe ColumnCryptoMetaData), - -- | Encrypted column metadata for this chunk - columnChunkEncryptedColumnMetadata :: (Maybe B.ByteString)} - deriving (Eq, Ord, Read, Show) - -_ColumnChunk = Core.Name "hydra.parquet.format.ColumnChunk" - -_ColumnChunk_filePath = Core.Name "filePath" - -_ColumnChunk_fileOffset = Core.Name "fileOffset" - -_ColumnChunk_metaData = Core.Name "metaData" - -_ColumnChunk_offsetIndexOffset = Core.Name "offsetIndexOffset" - -_ColumnChunk_offsetIndexLength = Core.Name "offsetIndexLength" - -_ColumnChunk_columnIndexOffset = Core.Name "columnIndexOffset" - -_ColumnChunk_columnIndexLength = Core.Name "columnIndexLength" - -_ColumnChunk_cryptoMetadata = Core.Name "cryptoMetadata" - -_ColumnChunk_encryptedColumnMetadata = Core.Name "encryptedColumnMetadata" - --- | Crypto metadata for a column, specifying which key was used to encrypt it -data ColumnCryptoMetaData = - ColumnCryptoMetaDataEncryptionWithFooterKey EncryptionWithFooterKey | - ColumnCryptoMetaDataEncryptionWithColumnKey EncryptionWithColumnKey - deriving (Eq, Ord, Read, Show) - -_ColumnCryptoMetaData = Core.Name "hydra.parquet.format.ColumnCryptoMetaData" - -_ColumnCryptoMetaData_encryptionWithFooterKey = Core.Name "encryptionWithFooterKey" - -_ColumnCryptoMetaData_encryptionWithColumnKey = Core.Name "encryptionWithColumnKey" - --- | Description for ColumnIndex. Each [i] refers to the page at OffsetIndex.page_locations[i] -data ColumnIndex = - ColumnIndex { - -- | A list of Boolean values to determine the validity of the corresponding min and max values. If true, a page contains only null values, and writers have to set the corresponding entries in min_values and max_values to byte[0], so that all lists have the same length. If false, the corresponding entries in min_values and max_values must be valid. - columnIndexNullPages :: [Bool], - -- | minValues and maxValues are lists containing lower and upper bounds for the values of each page determined by the ColumnOrder of the column. These may be the actual minimum and maximum values found on a page, but can also be (more compact) values that do not exist on a page. For example, instead of storing "Blart Versenwald III", a writer may set min_values[i]="B", max_values[i]="C". Such more compact values must still be valid values within the column's logical type. Readers must make sure that list entries are populated before using them by inspecting null_pages. - columnIndexMinValues :: [B.ByteString], - columnIndexMaxValues :: [B.ByteString], - -- | Stores whether both min_values and max_values are orderd and if so, in which direction. This allows readers to perform binary searches in both lists. Readers cannot assume that max_values[i] <= min_values[i+1], even if the lists are ordered. - columnIndexBoundaryOrder :: BoundaryOrder, - -- | A list containing the number of null values for each page - columnIndexNullCounts :: (Maybe [I.Int64])} - deriving (Eq, Ord, Read, Show) - -_ColumnIndex = Core.Name "hydra.parquet.format.ColumnIndex" - -_ColumnIndex_nullPages = Core.Name "nullPages" - -_ColumnIndex_minValues = Core.Name "minValues" - -_ColumnIndex_maxValues = Core.Name "maxValues" - -_ColumnIndex_boundaryOrder = Core.Name "boundaryOrder" - -_ColumnIndex_nullCounts = Core.Name "nullCounts" - --- | Description for column metadata -data ColumnMetaData = - ColumnMetaData { - -- | Type of this column - columnMetaDataType :: Type, - -- | Set of all encodings used for this column. The purpose is to validate whether we can decode those pages. - columnMetaDataEncodings :: [Encoding], - -- | Path in schema - columnMetaDataPathInSchema :: [String], - -- | Compression codec - columnMetaDataCodec :: CompressionCodec, - -- | Number of values in this column - columnMetaDataNumValues :: I.Int64, - -- | total byte size of all uncompressed pages in this column chunk (including the headers) - columnMetaDataTotalUncompressedSize :: I.Int64, - -- | total byte size of all compressed, and potentially encrypted, pages in this column chunk (including the headers) - columnMetaDataTotalCompressedSize :: I.Int64, - -- | Optional key/value metadata - columnMetaDataKeyValueMetadata :: (Maybe [KeyValue]), - -- | Byte offset from beginning of file to first data page - columnMetaDataDataPageOffset :: I.Int64, - -- | Byte offset from beginning of file to root index page - columnMetaDataIndexPageOffset :: (Maybe I.Int64), - -- | Byte offset from the beginning of file to first (only) dictionary page - columnMetaDataDictionaryPageOffset :: (Maybe I.Int64), - -- | optional statistics for this column chunk - columnMetaDataStatistics :: (Maybe Statistics), - -- | Set of all encodings used for pages in this column chunk. This information can be used to determine if all data pages are dictionary encoded for example - columnMetaDataEncodingStats :: (Maybe [PageEncodingStats]), - -- | Byte offset from beginning of file to Bloom filter data. - columnMetaDataBloomFilterOffset :: (Maybe I.Int64)} - deriving (Eq, Ord, Read, Show) - -_ColumnMetaData = Core.Name "hydra.parquet.format.ColumnMetaData" - -_ColumnMetaData_type = Core.Name "type" - -_ColumnMetaData_encodings = Core.Name "encodings" - -_ColumnMetaData_pathInSchema = Core.Name "pathInSchema" - -_ColumnMetaData_codec = Core.Name "codec" - -_ColumnMetaData_numValues = Core.Name "numValues" - -_ColumnMetaData_totalUncompressedSize = Core.Name "totalUncompressedSize" - -_ColumnMetaData_totalCompressedSize = Core.Name "totalCompressedSize" - -_ColumnMetaData_keyValueMetadata = Core.Name "keyValueMetadata" - -_ColumnMetaData_dataPageOffset = Core.Name "dataPageOffset" - -_ColumnMetaData_indexPageOffset = Core.Name "indexPageOffset" - -_ColumnMetaData_dictionaryPageOffset = Core.Name "dictionaryPageOffset" - -_ColumnMetaData_statistics = Core.Name "statistics" - -_ColumnMetaData_encodingStats = Core.Name "encodingStats" - -_ColumnMetaData_bloomFilterOffset = Core.Name "bloomFilterOffset" - --- | Union to specify the order used for the min_value and max_value fields for a column. This union takes the role of an enhanced enum that allows rich elements (which will be needed for a collation-based ordering in the future). Possible values are: --- | * TypeDefinedOrder - the column uses the order defined by its logical or physical type (if there is no logical type). --- | If the reader does not support the value of this union, min and max stats for this column should be ignored. -data ColumnOrder = - -- | The sort orders for logical types are: - -- | UTF8 - unsigned byte-wise comparison - -- | INT8 - signed comparison - -- | INT16 - signed comparison - -- | INT32 - signed comparison - -- | INT64 - signed comparison - -- | UINT8 - unsigned comparison - -- | UINT16 - unsigned comparison - -- | UINT32 - unsigned comparison - -- | UINT64 - unsigned comparison - -- | DECIMAL - signed comparison of the represented value - -- | DATE - signed comparison - -- | TIME_MILLIS - signed comparison - -- | TIME_MICROS - signed comparison - -- | TIMESTAMP_MILLIS - signed comparison - -- | TIMESTAMP_MICROS - signed comparison - -- | INTERVAL - unsigned comparison - -- | JSON - unsigned byte-wise comparison - -- | BSON - unsigned byte-wise comparison - -- | ENUM - unsigned byte-wise comparison - -- | LIST - undefined - -- | MAP - undefined - -- | In the absence of logical types, the sort order is determined by the physical type: - -- | BOOLEAN - false, true - -- | INT32 - signed comparison - -- | INT64 - signed comparison - -- | INT96 (only used for legacy timestamps) - undefined - -- | FLOAT - signed comparison of the represented value (*) - -- | DOUBLE - signed comparison of the represented value (*) - -- | BYTE_ARRAY - unsigned byte-wise comparison - -- | FIXED_LEN_BYTE_ARRAY - unsigned byte-wise comparison - -- | (*) Because the sorting order is not specified properly for floating - -- | point values (relations vs. total ordering) the following - -- | compatibility rules should be applied when reading statistics: - -- | - If the min is a NaN, it should be ignored. - -- | - If the max is a NaN, it should be ignored. - -- | - If the min is +0, the row group may contain -0 values as well. - -- | - If the max is -0, the row group may contain +0 values as well. - -- | - When looking for NaN values, min and max should be ignored. - ColumnOrderTypeOrder - deriving (Eq, Ord, Read, Show) - -_ColumnOrder = Core.Name "hydra.parquet.format.ColumnOrder" - -_ColumnOrder_typeOrder = Core.Name "typeOrder" - --- | Supported compression algorithms. Codecs added in format version X.Y can be read by readers based on X.Y and later. Codec support may vary between readers based on the format version and libraries available at runtime. See Compression.md for a detailed specification of these algorithms. -data CompressionCodec = - CompressionCodecUncompressed | - CompressionCodecSnappy | - CompressionCodecGzip | - CompressionCodecLzo | - -- | Added in 2.4 - CompressionCodecBrotli | - -- | Added in 2.4 - CompressionCodecZstd | - -- | Added in 2.9 - CompressionCodecLz4Raw - deriving (Eq, Ord, Read, Show) - -_CompressionCodec = Core.Name "hydra.parquet.format.CompressionCodec" - -_CompressionCodec_uncompressed = Core.Name "uncompressed" - -_CompressionCodec_snappy = Core.Name "snappy" - -_CompressionCodec_gzip = Core.Name "gzip" - -_CompressionCodec_lzo = Core.Name "lzo" - -_CompressionCodec_brotli = Core.Name "brotli" - -_CompressionCodec_zstd = Core.Name "zstd" - -_CompressionCodec_lz4Raw = Core.Name "lz4Raw" - --- | Data page header -data DataPageHeader = - DataPageHeader { - -- | Number of values, including NULLs, in this data page. - dataPageHeaderNumValues :: Int, - -- | Encoding used for this data page - dataPageHeaderEncoding :: Encoding, - -- | Encoding used for definition levels - dataPageHeaderDefinitionLevelEncoding :: Encoding, - -- | Encoding used for repetition levels - dataPageHeaderRepetitionLevelEncoding :: Encoding, - -- | Optional statistics for the data in this page - dataPageHeaderStatistics :: (Maybe Statistics)} - deriving (Eq, Ord, Read, Show) - -_DataPageHeader = Core.Name "hydra.parquet.format.DataPageHeader" - -_DataPageHeader_numValues = Core.Name "numValues" - -_DataPageHeader_encoding = Core.Name "encoding" - -_DataPageHeader_definitionLevelEncoding = Core.Name "definitionLevelEncoding" - -_DataPageHeader_repetitionLevelEncoding = Core.Name "repetitionLevelEncoding" - -_DataPageHeader_statistics = Core.Name "statistics" - --- | New page format allowing reading levels without decompressing the data Repetition and definition levels are uncompressed The remaining section containing the data is compressed if is_compressed is true -data DataPageHeaderV2 = - DataPageHeaderV2 { - -- | Number of values, including NULLs, in this data page. - dataPageHeaderV2NumValues :: Int, - -- | Number of NULL values, in this data page. Number of non-null = num_values - num_nulls which is also the number of values in the data section - dataPageHeaderV2NumNulls :: Int, - -- | Number of rows in this data page. which means pages change on record boundaries (r = 0) - dataPageHeaderV2NumRows :: Int, - -- | Encoding used for data in this page - dataPageHeaderV2Encoding :: Encoding, - -- | length of the definition levels - dataPageHeaderV2DefinitionLevelsByteLength :: Int, - -- | length of the repetition levels - dataPageHeaderV2RepetitionLevelsByteLength :: Int, - -- | whether the values are compressed. Which means the section of the page between definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included) is compressed with the compression_codec. If missing it is considered compressed - dataPageHeaderV2IsCompressed :: (Maybe Bool), - -- | optional statistics for the data in this page - dataPageHeaderV2Statistics :: (Maybe Statistics)} - deriving (Eq, Ord, Read, Show) - -_DataPageHeaderV2 = Core.Name "hydra.parquet.format.DataPageHeaderV2" - -_DataPageHeaderV2_numValues = Core.Name "numValues" - -_DataPageHeaderV2_numNulls = Core.Name "numNulls" - -_DataPageHeaderV2_numRows = Core.Name "numRows" - -_DataPageHeaderV2_encoding = Core.Name "encoding" - -_DataPageHeaderV2_definitionLevelsByteLength = Core.Name "definitionLevelsByteLength" - -_DataPageHeaderV2_repetitionLevelsByteLength = Core.Name "repetitionLevelsByteLength" - -_DataPageHeaderV2_isCompressed = Core.Name "isCompressed" - -_DataPageHeaderV2_statistics = Core.Name "statistics" - --- | Decimal logical type annotation. To maintain forward-compatibility in v1, implementations using this logical type must also set scale and precision on the annotated SchemaElement. Allowed for physical types: INT32, INT64, FIXED, and BINARY -data DecimalType = - DecimalType { - decimalTypeScale :: Int, - decimalTypePrecision :: Int} - deriving (Eq, Ord, Read, Show) - -_DecimalType = Core.Name "hydra.parquet.format.DecimalType" - -_DecimalType_scale = Core.Name "scale" - -_DecimalType_precision = Core.Name "precision" - --- | The dictionary page must be placed at the first position of the column chunk if it is partly or completely dictionary encoded. At most one dictionary page can be placed in a column chunk. -data DictionaryPageHeader = - DictionaryPageHeader { - -- | Number of values in the dictionary - dictionaryPageHeaderNumValues :: Int, - -- | Encoding using this dictionary page - dictionaryPageHeaderEncoding :: Encoding, - -- | If true, the entries in the dictionary are sorted in ascending order - dictionaryPageHeaderIsSorted :: (Maybe Bool)} - deriving (Eq, Ord, Read, Show) - -_DictionaryPageHeader = Core.Name "hydra.parquet.format.DictionaryPageHeader" - -_DictionaryPageHeader_numValues = Core.Name "numValues" - -_DictionaryPageHeader_encoding = Core.Name "encoding" - -_DictionaryPageHeader_isSorted = Core.Name "isSorted" - --- | Encodings supported by Parquet. Not all encodings are valid for all types. These enums are also used to specify the encoding of definition and repetition levels. See the accompanying doc for the details of the more complicated encodings. -data Encoding = - -- | Default encoding. - -- | BOOLEAN - 1 bit per value. 0 is false; 1 is true. - -- | INT32 - 4 bytes per value. Stored as little-endian. - -- | INT64 - 8 bytes per value. Stored as little-endian. - -- | FLOAT - 4 bytes per value. IEEE. Stored as little-endian. - -- | DOUBLE - 8 bytes per value. IEEE. Stored as little-endian. - -- | BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes. - -- | FIXED_LEN_BYTE_ARRAY - Just the bytes. - EncodingPlain | - -- | Group packed run length encoding. Usable for definition/repetition levels encoding and Booleans (on one bit: 0 is false; 1 is true.) - EncodingRle | - -- | Bit packed encoding. This can only be used if the data has a known max width. Usable for definition/repetition levels encoding. - EncodingBitPacked | - -- | Delta encoding for integers. This can be used for int columns and works best on sorted data - EncodingDeltaBinaryPacked | - -- | Encoding for byte arrays to separate the length values and the data. The lengths are encoded using DELTA_BINARY_PACKED - EncodingDeltaLengthByteArray | - -- | Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED. Suffixes are stored as delta length byte arrays. - EncodingDeltaByteArray | - -- | Dictionary encoding: the ids are encoded using the RLE encoding - EncodingRleDictionary | - -- | Encoding for floating-point data. K byte-streams are created where K is the size in bytes of the data type. The individual bytes of an FP value are scattered to the corresponding stream and the streams are concatenated. This itself does not reduce the size of the data but can lead to better compression afterwards. - EncodingByteStreamSplit - deriving (Eq, Ord, Read, Show) - -_Encoding = Core.Name "hydra.parquet.format.Encoding" - -_Encoding_plain = Core.Name "plain" - -_Encoding_rle = Core.Name "rle" - -_Encoding_bitPacked = Core.Name "bitPacked" - -_Encoding_deltaBinaryPacked = Core.Name "deltaBinaryPacked" - -_Encoding_deltaLengthByteArray = Core.Name "deltaLengthByteArray" - -_Encoding_deltaByteArray = Core.Name "deltaByteArray" - -_Encoding_rleDictionary = Core.Name "rleDictionary" - -_Encoding_byteStreamSplit = Core.Name "byteStreamSplit" - --- | The encryption algorithm used to protect a Parquet file, with its parameters -data EncryptionAlgorithm = - EncryptionAlgorithmAesGcmV1 AesGcmV1 | - EncryptionAlgorithmAesGcmCtrV1 AesGcmCtrV1 - deriving (Eq, Ord, Read, Show) - -_EncryptionAlgorithm = Core.Name "hydra.parquet.format.EncryptionAlgorithm" - -_EncryptionAlgorithm_aesGcmV1 = Core.Name "aesGcmV1" - -_EncryptionAlgorithm_aesGcmCtrV1 = Core.Name "aesGcmCtrV1" - --- | Identifies a column as encrypted with its own per-column encryption key -data EncryptionWithColumnKey = - EncryptionWithColumnKey { - -- | Column path in schema - encryptionWithColumnKeyPathInSchema :: [String], - -- | Retrieval metadata of column encryption key - encryptionWithColumnKeyKeyMetadata :: (Maybe B.ByteString)} - deriving (Eq, Ord, Read, Show) - -_EncryptionWithColumnKey = Core.Name "hydra.parquet.format.EncryptionWithColumnKey" - -_EncryptionWithColumnKey_pathInSchema = Core.Name "pathInSchema" - -_EncryptionWithColumnKey_keyMetadata = Core.Name "keyMetadata" - --- | Identifies a column as encrypted with the same key used to encrypt the footer -type EncryptionWithFooterKey = () - -_EncryptionWithFooterKey = Core.Name "hydra.parquet.format.EncryptionWithFooterKey" - --- | Representation of Schemas -data FieldRepetitionType = - -- | This field is required (can not be null) and each record has exactly 1 value. - FieldRepetitionTypeRequired | - -- | The field is optional (can be null) and each record has 0 or 1 values. - FieldRepetitionTypeOptional | - -- | The field is repeated and can contain 0 or more values - FieldRepetitionTypeRepeated - deriving (Eq, Ord, Read, Show) - -_FieldRepetitionType = Core.Name "hydra.parquet.format.FieldRepetitionType" - -_FieldRepetitionType_required = Core.Name "required" - -_FieldRepetitionType_optional = Core.Name "optional" - -_FieldRepetitionType_repeated = Core.Name "repeated" - --- | Crypto metadata for files with encrypted footer -data FileCryptoMetaData = - FileCryptoMetaData { - -- | Encryption algorithm. This field is only used for files with encrypted footer. Files with plaintext footer store algorithm id inside footer (FileMetaData structure). - fileCryptoMetaDataEncryptionAlgorithm :: EncryptionAlgorithm, - -- | Retrieval metadata of key used for encryption of footer, and (possibly) columns - fileCryptoMetaDataKeyMetadata :: (Maybe B.ByteString)} - deriving (Eq, Ord, Read, Show) - -_FileCryptoMetaData = Core.Name "hydra.parquet.format.FileCryptoMetaData" - -_FileCryptoMetaData_encryptionAlgorithm = Core.Name "encryptionAlgorithm" - -_FileCryptoMetaData_keyMetadata = Core.Name "keyMetadata" - --- | Description for file metadata -data FileMetaData = - FileMetaData { - -- | Version of this file - fileMetaDataVersion :: Int, - -- | Parquet schema for this file. This schema contains metadata for all the columns. The schema is represented as a tree with a single root. The nodes of the tree are flattened to a list by doing a depth-first traversal. The column metadata contains the path in the schema for that column which can be used to map columns to nodes in the schema. The first element is the root - fileMetaDataSchema :: [SchemaElement], - -- | Number of rows in this file - fileMetaDataNumRows :: I.Int64, - -- | Row groups in this file - fileMetaDataRowGroups :: [RowGroup], - -- | Optional key/value metadata - fileMetaDataKeyValueMetadata :: (Maybe [KeyValue]), - -- | String for application that wrote this file. This should be in the format version (build ). e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55) - fileMetaDataCreatedBy :: (Maybe String), - -- | Sort order used for the min_value and max_value fields in the Statistics objects and the min_values and max_values fields in the ColumnIndex objects of each column in this file. Sort orders are listed in the order matching the columns in the schema. The indexes are not necessary the same though, because only leaf nodes of the schema are represented in the list of sort orders. - -- | Without column_orders, the meaning of the min_value and max_value fields in the Statistics object and the ColumnIndex object is undefined. To ensure well-defined behaviour, if these fields are written to a Parquet file, column_orders must be written as well. - -- | The obsolete min and max fields in the Statistics object are always sorted by signed comparison regardless of column_orders. - fileMetaDataColumnOrders :: (Maybe [ColumnOrder]), - -- | Encryption algorithm. This field is set only in encrypted files with plaintext footer. Files with encrypted footer store algorithm id in FileCryptoMetaData structure. - fileMetaDataEncryptionAlgorithm :: (Maybe EncryptionAlgorithm), - -- | Retrieval metadata of key used for signing the footer. Used only in encrypted files with plaintext footer. - fileMetaDataFooterSigningKeyMetadata :: (Maybe B.ByteString)} - deriving (Eq, Ord, Read, Show) - -_FileMetaData = Core.Name "hydra.parquet.format.FileMetaData" - -_FileMetaData_version = Core.Name "version" - -_FileMetaData_schema = Core.Name "schema" - -_FileMetaData_numRows = Core.Name "numRows" - -_FileMetaData_rowGroups = Core.Name "rowGroups" - -_FileMetaData_keyValueMetadata = Core.Name "keyValueMetadata" - -_FileMetaData_createdBy = Core.Name "createdBy" - -_FileMetaData_columnOrders = Core.Name "columnOrders" - -_FileMetaData_encryptionAlgorithm = Core.Name "encryptionAlgorithm" - -_FileMetaData_footerSigningKeyMetadata = Core.Name "footerSigningKeyMetadata" - --- | Header for an index page (currently unused in the Parquet format) -type IndexPageHeader = () - -_IndexPageHeader = Core.Name "hydra.parquet.format.IndexPageHeader" - --- | Integer logical type annotation. bitWidth must be 8, 16, 32, or 64. Allowed for physical types: INT32, INT64 -data IntType = - IntType { - intTypeBitWidth :: I.Int16, - intTypeIsSigned :: Bool} - deriving (Eq, Ord, Read, Show) - -_IntType = Core.Name "hydra.parquet.format.IntType" - -_IntType_bitWidth = Core.Name "bitWidth" - -_IntType_isSigned = Core.Name "isSigned" - --- | Wrapper struct to store key values -data KeyValue = - KeyValue { - keyValueKey :: String, - keyValueValue :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_KeyValue = Core.Name "hydra.parquet.format.KeyValue" - -_KeyValue_key = Core.Name "key" - -_KeyValue_value = Core.Name "value" - --- | LogicalType annotations to replace ConvertedType. To maintain compatibility, implementations using LogicalType for a SchemaElement aust also set the corresponding ConvertedType (if any) from the following table. -data LogicalType = - -- | use ConvertedType UTF8 - LogicalTypeString | - -- | use ConvertedType MAP - LogicalTypeMap | - -- | use ConvertedType LIST - LogicalTypeList | - -- | use ConvertedType ENUM - LogicalTypeEnum | - -- | use ConvertedType DECIMAL + SchemaElement.{scale, precision} - LogicalTypeDecimal DecimalType | - -- | use ConvertedType DATE - LogicalTypeDate | - -- | use ConvertedType TIME_MICROS for TIME(isAdjustedToUTC = *, unit = MICROS). use ConvertedType TIME_MILLIS for TIME(isAdjustedToUTC = *, unit = MILLIS) - LogicalTypeTime TimeType | - -- | use ConvertedType TIMESTAMP_MICROS for TIMESTAMP(isAdjustedToUTC = *, unit = MICROS). use ConvertedType TIMESTAMP_MILLIS for TIMESTAMP(isAdjustedToUTC = *, unit = MILLIS) - LogicalTypeTimestamp TimestampType | - -- | use ConvertedType INT_* or UINT_* - LogicalTypeInteger IntType | - -- | no compatible ConvertedType - LogicalTypeUnknown | - -- | use ConvertedType JSON - LogicalTypeJson | - -- | use ConvertedType BSON - LogicalTypeBson | - -- | no compatible ConvertedType - LogicalTypeUuid - deriving (Eq, Ord, Read, Show) - -_LogicalType = Core.Name "hydra.parquet.format.LogicalType" - -_LogicalType_string = Core.Name "string" - -_LogicalType_map = Core.Name "map" - -_LogicalType_list = Core.Name "list" - -_LogicalType_enum = Core.Name "enum" - -_LogicalType_decimal = Core.Name "decimal" - -_LogicalType_date = Core.Name "date" - -_LogicalType_time = Core.Name "time" - -_LogicalType_timestamp = Core.Name "timestamp" - -_LogicalType_integer = Core.Name "integer" - -_LogicalType_unknown = Core.Name "unknown" - -_LogicalType_json = Core.Name "json" - -_LogicalType_bson = Core.Name "bson" - -_LogicalType_uuid = Core.Name "uuid" - --- | The offset index for a column chunk, giving byte offsets and row indices of its pages -data OffsetIndex = - OffsetIndex { - -- | PageLocations, ordered by increasing PageLocation.offset. It is required that page_locations[i].first_row_index < page_locations[i+1].first_row_index. - offsetIndexPageLocations :: [PageLocation]} - deriving (Eq, Ord, Read, Show) - -_OffsetIndex = Core.Name "hydra.parquet.format.OffsetIndex" - -_OffsetIndex_pageLocations = Core.Name "pageLocations" - --- | statistics of a given page type and encoding -data PageEncodingStats = - PageEncodingStats { - -- | the page type (data/dic/...) - pageEncodingStatsPageType :: PageType, - -- | encoding of the page - pageEncodingStatsEncoding :: Encoding, - -- | number of pages of this type with this encoding - pageEncodingStatsCount :: Int} - deriving (Eq, Ord, Read, Show) - -_PageEncodingStats = Core.Name "hydra.parquet.format.PageEncodingStats" - -_PageEncodingStats_pageType = Core.Name "pageType" - -_PageEncodingStats_encoding = Core.Name "encoding" - -_PageEncodingStats_count = Core.Name "count" - --- | Common header shared by all page types, wrapping a type-specific header -data PageHeader = - PageHeader { - -- | the type of the page: indicates which of the *_header fields is set - pageHeaderType :: PageType, - -- | Uncompressed page size in bytes (not including this header) - pageHeaderUncompressedPageSize :: Int, - -- | Compressed (and potentially encrypted) page size in bytes, not including this header - pageHeaderCompressedPageSize :: Int, - -- | The 32bit CRC for the page, to be be calculated as follows: - -- | - Using the standard CRC32 algorithm - -- | - On the data only, i.e. this header should not be included. 'Data' - -- | hereby refers to the concatenation of the repetition levels, the - -- | definition levels and the column value, in this exact order. - -- | - On the encoded versions of the repetition levels, definition levels and - -- | column values - -- | - On the compressed versions of the repetition levels, definition levels - -- | and column values where possible; - -- | - For v1 data pages, the repetition levels, definition levels and column - -- | values are always compressed together. If a compression scheme is - -- | specified, the CRC shall be calculated on the compressed version of - -- | this concatenation. If no compression scheme is specified, the CRC - -- | shall be calculated on the uncompressed version of this concatenation. - -- | - For v2 data pages, the repetition levels and definition levels are - -- | handled separately from the data and are never compressed (only - -- | encoded). If a compression scheme is specified, the CRC shall be - -- | calculated on the concatenation of the uncompressed repetition levels, - -- | uncompressed definition levels and the compressed column values. - -- | If no compression scheme is specified, the CRC shall be calculated on - -- | the uncompressed concatenation. - -- | - In encrypted columns, CRC is calculated after page encryption; the - -- | encryption itself is performed after page compression (if compressed) - -- | If enabled, this allows for disabling checksumming in HDFS if only a few pages need to be read. - pageHeaderCrc :: (Maybe Int), - pageHeaderDataPageHeader :: (Maybe DataPageHeader), - pageHeaderIndexPageHeader :: (Maybe IndexPageHeader), - pageHeaderDictionaryPageHeader :: (Maybe DictionaryPageHeader), - pageHeaderDataPageHeaderV2 :: (Maybe DataPageHeaderV2)} - deriving (Eq, Ord, Read, Show) - -_PageHeader = Core.Name "hydra.parquet.format.PageHeader" - -_PageHeader_type = Core.Name "type" - -_PageHeader_uncompressedPageSize = Core.Name "uncompressedPageSize" - -_PageHeader_compressedPageSize = Core.Name "compressedPageSize" - -_PageHeader_crc = Core.Name "crc" - -_PageHeader_dataPageHeader = Core.Name "dataPageHeader" - -_PageHeader_indexPageHeader = Core.Name "indexPageHeader" - -_PageHeader_dictionaryPageHeader = Core.Name "dictionaryPageHeader" - -_PageHeader_dataPageHeaderV2 = Core.Name "dataPageHeaderV2" - --- | Location and size of a single page, used as an entry in an OffsetIndex -data PageLocation = - PageLocation { - -- | Offset of the page in the file - pageLocationOffset :: I.Int64, - -- | Size of the page, including header. Sum of compressed_page_size and header length - pageLocationCompressedPageSize :: Int, - -- | Index within the RowGroup of the first row of the page; this means pages change on record boundaries (r = 0). - pageLocationFirstRowIndex :: I.Int64} - deriving (Eq, Ord, Read, Show) - -_PageLocation = Core.Name "hydra.parquet.format.PageLocation" - -_PageLocation_offset = Core.Name "offset" - -_PageLocation_compressedPageSize = Core.Name "compressedPageSize" - -_PageLocation_firstRowIndex = Core.Name "firstRowIndex" - --- | The type of a page within a column chunk -data PageType = - PageTypeDataPage | - PageTypeIndexPage | - PageTypeDictionaryPage | - PageTypeDataPageV2 - deriving (Eq, Ord, Read, Show) - -_PageType = Core.Name "hydra.parquet.format.PageType" - -_PageType_dataPage = Core.Name "dataPage" - -_PageType_indexPage = Core.Name "indexPage" - -_PageType_dictionaryPage = Core.Name "dictionaryPage" - -_PageType_dataPageV2 = Core.Name "dataPageV2" - --- | Metadata for a horizontal partition of the data into a row group -data RowGroup = - RowGroup { - -- | Metadata for each column chunk in this row group. This list must have the same order as the SchemaElement list in FileMetaData. - rowGroupColumns :: [ColumnChunk], - -- | Total byte size of all the uncompressed column data in this row group - rowGroupTotalByteSize :: I.Int64, - -- | Number of rows in this row group - rowGroupNumRows :: I.Int64, - -- | If set, specifies a sort ordering of the rows in this RowGroup. The sorting columns can be a subset of all the columns. - rowGroupSortingColumns :: (Maybe [SortingColumn]), - -- | Byte offset from beginning of file to first page (data or dictionary) in this row group - rowGroupFileOffset :: (Maybe I.Int64), - -- | Total byte size of all compressed (and potentially encrypted) column data in this row group - rowGroupTotalCompressedSize :: (Maybe I.Int64), - -- | Row group ordinal in the file - rowGroupOrdinal :: (Maybe I.Int16)} - deriving (Eq, Ord, Read, Show) - -_RowGroup = Core.Name "hydra.parquet.format.RowGroup" - -_RowGroup_columns = Core.Name "columns" - -_RowGroup_totalByteSize = Core.Name "totalByteSize" - -_RowGroup_numRows = Core.Name "numRows" - -_RowGroup_sortingColumns = Core.Name "sortingColumns" - -_RowGroup_fileOffset = Core.Name "fileOffset" - -_RowGroup_totalCompressedSize = Core.Name "totalCompressedSize" - -_RowGroup_ordinal = Core.Name "ordinal" - --- | Represents a element inside a schema definition. --- | - if it is a group (inner node) then type is undefined and num_children is defined --- | - if it is a primitive type (leaf) then type is defined and num_children is undefined --- | the nodes are listed in depth first traversal order. -data SchemaElement = - SchemaElement { - -- | Data type for this field. Not set if the current element is a non-leaf node - schemaElementType :: (Maybe Type), - -- | If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values. Otherwise, if specified, this is the maximum bit length to store any of the values. (e.g. a low cardinality INT col could have this set to 3). Note that this is in the schema, and therefore fixed for the entire file. - schemaElementTypeLength :: (Maybe Int), - -- | repetition of the field. The root of the schema does not have a repetition_type. All other nodes must have one - schemaElementRepetitionType :: (Maybe FieldRepetitionType), - -- | Name of the field in the schema - schemaElementName :: String, - -- | Nested fields. Since thrift does not support nested fields, the nesting is flattened to a single list by a depth-first traversal. The children count is used to construct the nested relationship. This field is not set when the element is a primitive type - schemaElementNumChildren :: (Maybe Int), - -- | When the original schema supports field ids, this will save the original field id in the parquet schema - schemaElementFieldId :: (Maybe Int), - -- | The logical type of this SchemaElement. LogicalType replaces ConvertedType, but ConvertedType is still required for some logical types to ensure forward-compatibility in format v1. - schemaElementLogicalType :: (Maybe LogicalType)} - deriving (Eq, Ord, Read, Show) - -_SchemaElement = Core.Name "hydra.parquet.format.SchemaElement" - -_SchemaElement_type = Core.Name "type" - -_SchemaElement_typeLength = Core.Name "typeLength" - -_SchemaElement_repetitionType = Core.Name "repetitionType" - -_SchemaElement_name = Core.Name "name" - -_SchemaElement_numChildren = Core.Name "numChildren" - -_SchemaElement_fieldId = Core.Name "fieldId" - -_SchemaElement_logicalType = Core.Name "logicalType" - --- | Wrapper struct to specify sort order -data SortingColumn = - SortingColumn { - -- | The column index (in this row group) - sortingColumnColumnIdx :: Int, - -- | If true, indicates this column is sorted in descending order. - sortingColumnDescending :: Bool, - -- | If true, nulls will come before non-null values, otherwise, nulls go at the end. - sortingColumnNullsFirst :: Bool} - deriving (Eq, Ord, Read, Show) - -_SortingColumn = Core.Name "hydra.parquet.format.SortingColumn" - -_SortingColumn_columnIdx = Core.Name "columnIdx" - -_SortingColumn_descending = Core.Name "descending" - -_SortingColumn_nullsFirst = Core.Name "nullsFirst" - --- | Statistics per row group and per page. All fields are optional. -data Statistics = - Statistics { - statisticsNullCount :: (Maybe Integer), - statisticsDistinctCount :: (Maybe Integer), - -- | Max value for the column, determined by its ColumnOrder. Values are encoded using PLAIN encoding, except that variable-length byte arrays do not include a length prefix. - statisticsMaxValue :: (Maybe B.ByteString), - -- | Max value for the column, determined by its ColumnOrder. Values are encoded using PLAIN encoding, except that variable-length byte arrays do not include a length prefix. - statisticsMinValue :: (Maybe B.ByteString)} - deriving (Eq, Ord, Read, Show) - -_Statistics = Core.Name "hydra.parquet.format.Statistics" - -_Statistics_nullCount = Core.Name "nullCount" - -_Statistics_distinctCount = Core.Name "distinctCount" - -_Statistics_maxValue = Core.Name "maxValue" - -_Statistics_minValue = Core.Name "minValue" - --- | Time logical type annotation. Allowed for physical types: INT32 (millis), INT64 (micros, nanos) -data TimeType = - TimeType { - timeTypeIsAdjustedToUtc :: Bool, - timeTypeUnit :: TimeUnit} - deriving (Eq, Ord, Read, Show) - -_TimeType = Core.Name "hydra.parquet.format.TimeType" - -_TimeType_isAdjustedToUtc = Core.Name "isAdjustedToUtc" - -_TimeType_unit = Core.Name "unit" - --- | The unit of measurement for a TIME or TIMESTAMP logical type -data TimeUnit = - TimeUnitMillis | - TimeUnitMicros | - TimeUnitNanos - deriving (Eq, Ord, Read, Show) - -_TimeUnit = Core.Name "hydra.parquet.format.TimeUnit" - -_TimeUnit_millis = Core.Name "millis" - -_TimeUnit_micros = Core.Name "micros" - -_TimeUnit_nanos = Core.Name "nanos" - --- | Timestamp logical type annotation. Allowed for physical types: INT64 -data TimestampType = - TimestampType { - timestampTypeIsAdjustedToUtc :: Bool, - timestampTypeUnit :: TimeUnit} - deriving (Eq, Ord, Read, Show) - -_TimestampType = Core.Name "hydra.parquet.format.TimestampType" - -_TimestampType_isAdjustedToUtc = Core.Name "isAdjustedToUtc" - -_TimestampType_unit = Core.Name "unit" - --- | Types supported by Parquet. These types are intended to be used in combination with the encodings to control the on disk storage format. For example INT16 is not included as a type since a good encoding of INT32 would handle this. -data Type = - TypeBoolean | - TypeInt32 | - TypeInt64 | - TypeFloat | - TypeDouble | - TypeByteArray | - TypeFixedLenByteArray - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.parquet.format.Type" - -_Type_boolean = Core.Name "boolean" - -_Type_int32 = Core.Name "int32" - -_Type_int64 = Core.Name "int64" - -_Type_float = Core.Name "float" - -_Type_double = Core.Name "double" - -_Type_byteArray = Core.Name "byteArray" - -_Type_fixedLenByteArray = Core.Name "fixedLenByteArray" diff --git a/src/main/haskell/Hydra/Pegasus/Coder.hs b/src/main/haskell/Hydra/Pegasus/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Pegasus/Coder.hs +++ /dev/null @@ -1,305 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Pegasus PDL code generator: converts Hydra modules to PDL schema files - -module Hydra.Pegasus.Coder where - -import qualified Hydra.Analysis as Analysis -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Dependencies as Dependencies -import qualified Hydra.Docs as Docs -import qualified Hydra.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.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.Maps as Maps -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.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Pegasus.Language as Language -import qualified Hydra.Pegasus.Pdl as Pdl -import qualified Hydra.Pegasus.Serde as Serde -import qualified Hydra.Print.Core as PrintCore -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Construct PDL schema files from type definitions, with topological sorting and cycle detection -constructModule :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Packaging.Module -> [Packaging.TypeDefinition] -> Either Errors.Error (M.Map String Pdl.SchemaFile) -constructModule cx g aliases mod typeDefs = - - let groups = Dependencies.topologicalSortTypeDefinitions typeDefs - in (Optionals.match (Lists.find (\grp -> Ordering.gt (Lists.length grp) 1) groups) ( - let sortedDefs = Lists.concat groups - in (Eithers.bind (Eithers.mapList (\typeDef -> typeToSchema cx g aliases mod typeDef) sortedDefs) (\schemas -> Right (Maps.fromList (Lists.map (toPair mod aliases) schemas))))) (\cycle -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "types form a cycle (unsupported in PDL): [" (Strings.concat2 (Strings.join ", " (Lists.map (\td -> Core.unName (Packaging.typeDefinitionName td)) cycle)) "]")))))) - --- | Create PDL annotations from an optional doc string -doc :: Maybe String -> Pdl.Annotations -doc s = - Pdl.Annotations { - Pdl.annotationsDoc = s, - Pdl.annotationsDeprecated = False} - --- | Encode a Hydra type as a PDL schema, failing if it resolves to a nested named schema -encode :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.Type -> Either Errors.Error Pdl.Schema -encode cx g aliases t = - case (Strip.deannotateType t) of - Core.TypeRecord v0 -> Logic.ifElse (Lists.isEmpty v0) (encode cx g aliases (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))) (Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintCore.type_ t))))) res)) - _ -> Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintCore.type_ t))))) res) - --- | Encode a Hydra field type as a PDL enum field, converting the name to upper snake case -encodeEnumField :: t0 -> Graph.Graph -> Core.FieldType -> Either Errors.Error Pdl.EnumField -encodeEnumField cx g ft = - - let name = Core.fieldTypeName ft - typ = Core.fieldTypeType ft - in (Eithers.bind (getAnns cx g typ) (\anns -> Right (Pdl.EnumField { - Pdl.enumFieldName = (Pdl.EnumFieldName (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionUpperSnake (Core.unName name))), - Pdl.enumFieldAnnotations = anns}))) - --- | Encode a type as a PDL schema together with a flag indicating whether it was optional -encodePossiblyOptionalType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.Type -> Either Errors.Error (Pdl.Schema, Bool) -encodePossiblyOptionalType cx g aliases typ = - case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> Eithers.bind (encode cx g aliases v0) (\t -> Right (t, True)) - Core.TypeRecord _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeUnion _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeLiteral _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeList _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeMap _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeSet _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeVariable _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeWrap _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeEither _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypePair _ -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeVoid -> Eithers.bind (encode cx g aliases typ) (\t -> Right (t, False)) - Core.TypeAnnotated v0 -> encodePossiblyOptionalType cx g aliases (Core.annotatedTypeBody v0) - --- | Encode a Hydra field type as a PDL record field -encodeRecordField :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.FieldType -> Either Errors.Error Pdl.RecordField -encodeRecordField cx g aliases ft = - - let name = Core.fieldTypeName ft - typ = Core.fieldTypeType ft - in (Eithers.bind (getAnns cx g typ) (\anns -> Eithers.bind (encodePossiblyOptionalType cx g aliases typ) (\optResult -> - let schema = Pairs.first optResult - optional = Pairs.second optResult - in (Right (Pdl.RecordField { - Pdl.recordFieldName = (Pdl.FieldName (Core.unName name)), - Pdl.recordFieldValue = schema, - Pdl.recordFieldOptional = optional, - Pdl.recordFieldDefault = Nothing, - Pdl.recordFieldAnnotations = anns}))))) - --- | Encode a Hydra type as either a PDL Schema (Left) or a PDL NamedSchemaType (Right) -encodeType :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.Type -> Either Errors.Error (Either Pdl.Schema Pdl.NamedSchemaType) -encodeType cx g aliases typ = - case typ of - Core.TypeAnnotated v0 -> encodeType cx g aliases (Core.annotatedTypeBody v0) - Core.TypeEither v0 -> Eithers.bind (encode cx g aliases (Core.eitherTypeLeft v0)) (\leftSchema -> Eithers.bind (encode cx g aliases (Core.eitherTypeRight v0)) (\rightSchema -> - let leftMember = - Pdl.UnionMember { - Pdl.unionMemberAlias = (Just (Pdl.FieldName "left")), - Pdl.unionMemberValue = leftSchema, - Pdl.unionMemberAnnotations = noAnnotations} - rightMember = - Pdl.UnionMember { - Pdl.unionMemberAlias = (Just (Pdl.FieldName "right")), - Pdl.unionMemberValue = rightSchema, - Pdl.unionMemberAnnotations = noAnnotations} - in (Right (Left (Pdl.SchemaUnion (Pdl.UnionSchema [ - leftMember, - rightMember])))))) - Core.TypeList v0 -> Eithers.bind (encode cx g aliases v0) (\inner -> Right (Left (Pdl.SchemaArray inner))) - Core.TypeLiteral v0 -> case v0 of - Core.LiteralTypeBinary -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeBytes)) - Core.LiteralTypeBoolean -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeBoolean)) - Core.LiteralTypeFloat v1 -> case v1 of - Core.FloatTypeFloat32 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeFloat)) - Core.FloatTypeFloat64 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeDouble)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "float32 or float64" (Strings.concat2 ", found: " (PrintCore.type_ typ)))))) - Core.LiteralTypeInteger v1 -> case v1 of - Core.IntegerTypeInt32 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeInt)) - Core.IntegerTypeInt64 -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeLong)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "int32 or int64" (Strings.concat2 ", found: " (PrintCore.type_ typ)))))) - Core.LiteralTypeString -> Right (Left (Pdl.SchemaPrimitive Pdl.PrimitiveTypeString)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "PDL-supported literal type" (Strings.concat2 ", found: " (PrintCore.type_ typ)))))) - Core.TypeMap v0 -> Eithers.bind (encode cx g aliases (Core.mapTypeValues v0)) (\inner -> Right (Left (Pdl.SchemaMap inner))) - Core.TypePair v0 -> Eithers.bind (encode cx g aliases (Core.pairTypeFirst v0)) (\firstSchema -> Eithers.bind (encode cx g aliases (Core.pairTypeSecond v0)) (\secondSchema -> - let firstField = - Pdl.RecordField { - Pdl.recordFieldName = (Pdl.FieldName "first"), - Pdl.recordFieldValue = firstSchema, - Pdl.recordFieldOptional = False, - Pdl.recordFieldDefault = Nothing, - Pdl.recordFieldAnnotations = noAnnotations} - secondField = - Pdl.RecordField { - Pdl.recordFieldName = (Pdl.FieldName "second"), - Pdl.recordFieldValue = secondSchema, - Pdl.recordFieldOptional = False, - Pdl.recordFieldDefault = Nothing, - Pdl.recordFieldAnnotations = noAnnotations} - in (Right (Right (Pdl.NamedSchemaTypeRecord (Pdl.RecordSchema { - Pdl.recordSchemaFields = [ - firstField, - secondField], - Pdl.recordSchemaIncludes = []})))))) - Core.TypeSet v0 -> Eithers.bind (encode cx g aliases v0) (\inner -> Right (Left (Pdl.SchemaArray inner))) - Core.TypeVariable v0 -> Right (Left (Pdl.SchemaNamed (pdlNameForElement aliases True v0))) - Core.TypeWrap v0 -> encodeType cx g aliases v0 - Core.TypeOptional _ -> Left (Errors.ErrorOther (Errors.OtherError "optionals unexpected at top level")) - Core.TypeRecord v0 -> Eithers.bind (Eithers.mapList (encodeRecordField cx g aliases) v0) (\rfields -> Right (Right (Pdl.NamedSchemaTypeRecord (Pdl.RecordSchema { - Pdl.recordSchemaFields = rfields, - Pdl.recordSchemaIncludes = []})))) - Core.TypeUnion v0 -> Logic.ifElse (Lists.foldl (\b -> \t -> Logic.and b (Equality.equal (Strip.deannotateType t) Core.TypeUnit)) True (Lists.map (\f -> Core.fieldTypeType f) v0)) (Eithers.bind (Eithers.mapList (encodeEnumField cx g) v0) (\fs -> Right (Right (Pdl.NamedSchemaTypeEnum (Pdl.EnumSchema { - Pdl.enumSchemaFields = fs}))))) (Eithers.bind (Eithers.mapList (encodeUnionField cx g aliases) v0) (\members -> Right (Left (Pdl.SchemaUnion (Pdl.UnionSchema members))))) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "Expected " (Strings.concat2 "PDL-supported type" (Strings.concat2 ", found: " (PrintCore.type_ typ)))))) - --- | Encode a Hydra field type as a PDL union member, wrapping optional types in a null union -encodeUnionField :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.FieldType -> Either Errors.Error Pdl.UnionMember -encodeUnionField cx g aliases ft = - - let name = Core.fieldTypeName ft - typ = Core.fieldTypeType ft - in (Eithers.bind (getAnns cx g typ) (\anns -> Eithers.bind (encodePossiblyOptionalType cx g aliases typ) (\optResult -> - let s = Pairs.first optResult - optional = Pairs.second optResult - schema = - Logic.ifElse optional (Pdl.SchemaUnion (Pdl.UnionSchema (Lists.map (\ms -> simpleUnionMember ms) [ - Pdl.SchemaNull, - s]))) s - in (Right (Pdl.UnionMember { - Pdl.unionMemberAlias = (Just (Pdl.FieldName (Core.unName name))), - Pdl.unionMemberValue = schema, - Pdl.unionMemberAnnotations = anns}))))) - --- | Get PDL annotations for a type by looking up its description in the graph -getAnns :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error Pdl.Annotations -getAnns cx g typ = Eithers.bind (Annotations.getTypeDescription cx g typ) (\r -> Right (doc r)) - --- | Compute import aliases for a module's dependencies -importAliasesForModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (M.Map Packaging.ModuleName String) -importAliasesForModule cx g mod = - Eithers.bind (Analysis.moduleDependencyModuleNames cx g False True True False mod) (\nss -> Right (Maps.fromList (Lists.map (\ns_ -> (ns_, (slashesToDots (Packaging.unModuleName ns_)))) (Sets.toList nss)))) - --- | Convert a Hydra module to a map of file paths to PDL schema strings -moduleToPdl :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String) -moduleToPdl mod defs cx g = - Eithers.bind (moduleToPegasusSchemas cx g mod defs) (\files -> Right (Maps.fromList (Lists.map (\pair -> (Pairs.first pair, (Serialization.printExpr (Serialization.parenthesize (Serde.schemaFileToExpr (Pairs.second pair)))))) (Maps.toList files)))) - --- | Convert a Hydra module and its definitions to PDL schema files -moduleToPegasusSchemas :: t0 -> Graph.Graph -> Packaging.Module -> [Packaging.Definition] -> Either Errors.Error (M.Map String Pdl.SchemaFile) -moduleToPegasusSchemas cx g mod defs = - - let partitioned = Environment.partitionDefinitions defs - typeDefs = Pairs.first partitioned - in (Eithers.bind (importAliasesForModule cx g mod) (\aliases -> constructModule cx g aliases mod typeDefs)) - --- | Empty PDL annotations -noAnnotations :: Pdl.Annotations -noAnnotations = - Pdl.Annotations { - Pdl.annotationsDoc = Nothing, - Pdl.annotationsDeprecated = False} - --- | Convert a Hydra element name to a PDL qualified name -pdlNameForElement :: M.Map Packaging.ModuleName String -> Bool -> Core.Name -> Pdl.QualifiedName -pdlNameForElement aliases withNs name = - - let qn = Names.qualifyName name - ns_ = Util.qualifiedNameModuleName qn - local = Util.qualifiedNameLocal qn - alias = Optionals.bind ns_ (\n -> Maps.lookup n aliases) - in Pdl.QualifiedName { - Pdl.qualifiedNameName = (Pdl.Name local), - Pdl.qualifiedNameNamespace = (Logic.ifElse withNs (Optionals.map (\a -> Pdl.Namespace a) alias) Nothing)} - --- | Convert a module's namespace to a PDL namespace -pdlNameForModule :: Packaging.Module -> Pdl.Namespace -pdlNameForModule mod = Pdl.Namespace (slashesToDots (Packaging.unModuleName (Packaging.moduleName mod))) - --- | Create a simple union member without an alias -simpleUnionMember :: Pdl.Schema -> Pdl.UnionMember -simpleUnionMember schema = - Pdl.UnionMember { - Pdl.unionMemberAlias = Nothing, - Pdl.unionMemberValue = schema, - Pdl.unionMemberAnnotations = noAnnotations} - --- | Replace all forward slashes with dots in a string -slashesToDots :: String -> String -slashesToDots s = Strings.join "." (Strings.splitOn "/" s) - --- | Pair a file path derived from a module and schema name with the resulting PDL schema file -toPair :: Packaging.Module -> t0 -> (Pdl.NamedSchema, [Pdl.QualifiedName]) -> (String, Pdl.SchemaFile) -toPair mod aliases schemaPair = - - let schema = Pairs.first schemaPair - imports = Pairs.second schemaPair - ns_ = pdlNameForModule mod - local = Pdl.unName (Pdl.qualifiedNameName (Pdl.namedSchemaQualifiedName schema)) - path = - Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "pdl") (Packaging.ModuleName (Strings.concat2 (Packaging.unModuleName (Packaging.moduleName mod)) (Strings.concat2 "/" local))) - in ( - path, - Pdl.SchemaFile { - Pdl.schemaFileNamespace = ns_, - Pdl.schemaFilePackage = Nothing, - Pdl.schemaFileImports = imports, - Pdl.schemaFileSchemas = [ - schema]}) - --- | Convert a Hydra type definition into a named PDL schema together with its imports -typeToSchema :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> t1 -> Packaging.TypeDefinition -> Either Errors.Error (Pdl.NamedSchema, [t2]) -typeToSchema cx g aliases mod typeDef = - - let typ = Core.typeSchemeBody (Packaging.typeDefinitionBody typeDef) - in (Eithers.bind (encodeType cx g aliases typ) (\res -> - let ptype = Eithers.either (\schema -> Pdl.NamedSchemaTypeTyperef schema) (\t -> t) res - in (Eithers.bind (Annotations.getTypeDescription cx g typ) (\descr -> - let anns = doc descr - qname = pdlNameForElement aliases False (Packaging.typeDefinitionName typeDef) - in (Right ( - Pdl.NamedSchema { - Pdl.namedSchemaQualifiedName = qname, - Pdl.namedSchemaType = ptype, - Pdl.namedSchemaAnnotations = anns}, - [])))))) diff --git a/src/main/haskell/Hydra/Pegasus/Language.hs b/src/main/haskell/Hydra/Pegasus/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Pegasus/Language.hs +++ /dev/null @@ -1,112 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for LinkedIn Pegasus (PDL) - -module Hydra.Pegasus.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Language constraints for LinkedIn Pegasus (PDL) -pdlLanguage :: Coders.Language -pdlLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.pegasus.pdl"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "pdl")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt32, - Core.IntegerTypeInt64] - termVariants = - Sets.fromList [ - Variants.TermVariantEither, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantPair, - Variants.TermVariantSet, - Variants.TermVariantWrap, - Variants.TermVariantOptional, - Variants.TermVariantRecord, - Variants.TermVariantInject] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantEither, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantPair, - Variants.TypeVariantSet, - Variants.TypeVariantWrap, - Variants.TypeVariantOptional, - Variants.TypeVariantRecord, - Variants.TypeVariantUnion, - Variants.TypeVariantVariable] - typePredicate = \_ -> True diff --git a/src/main/haskell/Hydra/Pegasus/Pdl.hs b/src/main/haskell/Hydra/Pegasus/Pdl.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Pegasus/Pdl.hs +++ /dev/null @@ -1,288 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for PDL (Pegasus Data Language) schemas. Based on the specification at: --- | https://linkedin.github.io/rest.li/pdl_schema - -module Hydra.Pegasus.Pdl where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Annotations which can be applied to record fields, aliased union members, enum symbols, or named schemas -data Annotations = - Annotations { - annotationsDoc :: (Maybe String), - annotationsDeprecated :: Bool} - deriving (Eq, Ord, Read, Show) - -_Annotations = Core.Name "hydra.pegasus.pdl.Annotations" - -_Annotations_doc = Core.Name "doc" - -_Annotations_deprecated = Core.Name "deprecated" - --- | A single symbol of a PDL enum schema, with its optional annotations -data EnumField = - EnumField { - enumFieldName :: EnumFieldName, - enumFieldAnnotations :: Annotations} - deriving (Eq, Ord, Read, Show) - -_EnumField = Core.Name "hydra.pegasus.pdl.EnumField" - -_EnumField_name = Core.Name "name" - -_EnumField_annotations = Core.Name "annotations" - --- | The name of a PDL enum symbol, conventionally in upper snake case -newtype EnumFieldName = - EnumFieldName { - unEnumFieldName :: String} - deriving (Eq, Ord, Read, Show) - -_EnumFieldName = Core.Name "hydra.pegasus.pdl.EnumFieldName" - --- | A PDL enum schema, defined as a fixed set of enumerated symbols -data EnumSchema = - EnumSchema { - enumSchemaFields :: [EnumField]} - deriving (Eq, Ord, Read, Show) - -_EnumSchema = Core.Name "hydra.pegasus.pdl.EnumSchema" - -_EnumSchema_fields = Core.Name "fields" - --- | The name of a record field or an aliased union member -newtype FieldName = - FieldName { - unFieldName :: String} - deriving (Eq, Ord, Read, Show) - -_FieldName = Core.Name "hydra.pegasus.pdl.FieldName" - --- | The unqualified (non-namespaced) name of a PDL named schema -newtype Name = - Name { - unName :: String} - deriving (Eq, Ord, Read, Show) - -_Name = Core.Name "hydra.pegasus.pdl.Name" - --- | A PDL schema that has a qualified name: a record, enum, or typeref -data NamedSchema = - NamedSchema { - namedSchemaQualifiedName :: QualifiedName, - namedSchemaType :: NamedSchemaType, - namedSchemaAnnotations :: Annotations} - deriving (Eq, Ord, Read, Show) - -_NamedSchema = Core.Name "hydra.pegasus.pdl.NamedSchema" - -_NamedSchema_qualifiedName = Core.Name "qualifiedName" - -_NamedSchema_type = Core.Name "type" - -_NamedSchema_annotations = Core.Name "annotations" - --- | The variety of a PDL named schema: record, enum, or typeref -data NamedSchemaType = - NamedSchemaTypeRecord RecordSchema | - NamedSchemaTypeEnum EnumSchema | - NamedSchemaTypeTyperef Schema - deriving (Eq, Ord, Read, Show) - -_NamedSchemaType = Core.Name "hydra.pegasus.pdl.NamedSchemaType" - -_NamedSchemaType_record = Core.Name "record" - -_NamedSchemaType_enum = Core.Name "enum" - -_NamedSchemaType_typeref = Core.Name "typeref" - --- | A dot-separated PDL namespace, analogous to a Java package name -newtype Namespace = - Namespace { - unNamespace :: String} - deriving (Eq, Ord, Read, Show) - -_Namespace = Core.Name "hydra.pegasus.pdl.Namespace" - --- | The Java package under which generated bindings for a schema file are placed -newtype Package = - Package { - unPackage :: String} - deriving (Eq, Ord, Read, Show) - -_Package = Core.Name "hydra.pegasus.pdl.Package" - --- | One of the built-in PDL primitive types -data PrimitiveType = - PrimitiveTypeBoolean | - PrimitiveTypeBytes | - PrimitiveTypeDouble | - PrimitiveTypeFloat | - PrimitiveTypeInt | - PrimitiveTypeLong | - PrimitiveTypeString - deriving (Eq, Ord, Read, Show) - -_PrimitiveType = Core.Name "hydra.pegasus.pdl.PrimitiveType" - -_PrimitiveType_boolean = Core.Name "boolean" - -_PrimitiveType_bytes = Core.Name "bytes" - -_PrimitiveType_double = Core.Name "double" - -_PrimitiveType_float = Core.Name "float" - -_PrimitiveType_int = Core.Name "int" - -_PrimitiveType_long = Core.Name "long" - -_PrimitiveType_string = Core.Name "string" - --- | A custom key/value property attached to a PDL schema, field, or member -data Property = - Property { - propertyKey :: PropertyKey, - propertyValue :: (Maybe Model.Value)} - deriving (Eq, Ord, Read, Show) - -_Property = Core.Name "hydra.pegasus.pdl.Property" - -_Property_key = Core.Name "key" - -_Property_value = Core.Name "value" - --- | The key of a custom PDL schema property, e.g. a dot-separated path -newtype PropertyKey = - PropertyKey { - unPropertyKey :: String} - deriving (Eq, Ord, Read, Show) - -_PropertyKey = Core.Name "hydra.pegasus.pdl.PropertyKey" - --- | A PDL name together with the optional namespace that qualifies it -data QualifiedName = - QualifiedName { - qualifiedNameName :: Name, - qualifiedNameNamespace :: (Maybe Namespace)} - deriving (Eq, Ord, Read, Show) - -_QualifiedName = Core.Name "hydra.pegasus.pdl.QualifiedName" - -_QualifiedName_name = Core.Name "name" - -_QualifiedName_namespace = Core.Name "namespace" - --- | Note: the default value for an enum-valued must be one of the enumerated string symbols -data RecordField = - RecordField { - recordFieldName :: FieldName, - recordFieldValue :: Schema, - recordFieldOptional :: Bool, - recordFieldDefault :: (Maybe Model.Value), - recordFieldAnnotations :: Annotations} - deriving (Eq, Ord, Read, Show) - -_RecordField = Core.Name "hydra.pegasus.pdl.RecordField" - -_RecordField_name = Core.Name "name" - -_RecordField_value = Core.Name "value" - -_RecordField_optional = Core.Name "optional" - -_RecordField_default = Core.Name "default" - -_RecordField_annotations = Core.Name "annotations" - --- | Note: all included schemas must be record schemas -data RecordSchema = - RecordSchema { - recordSchemaFields :: [RecordField], - recordSchemaIncludes :: [NamedSchema]} - deriving (Eq, Ord, Read, Show) - -_RecordSchema = Core.Name "hydra.pegasus.pdl.RecordSchema" - -_RecordSchema_fields = Core.Name "fields" - -_RecordSchema_includes = Core.Name "includes" - --- | A PDL data schema: either a primitive, a reference by name, or a complex type -data Schema = - SchemaArray Schema | - SchemaFixed Int | - SchemaInline NamedSchema | - SchemaMap Schema | - SchemaNamed QualifiedName | - SchemaNull | - SchemaPrimitive PrimitiveType | - SchemaUnion UnionSchema - deriving (Eq, Ord, Read, Show) - -_Schema = Core.Name "hydra.pegasus.pdl.Schema" - -_Schema_array = Core.Name "array" - -_Schema_fixed = Core.Name "fixed" - -_Schema_inline = Core.Name "inline" - -_Schema_map = Core.Name "map" - -_Schema_named = Core.Name "named" - -_Schema_null = Core.Name "null" - -_Schema_primitive = Core.Name "primitive" - -_Schema_union = Core.Name "union" - --- | A .pdl source file: a namespace declaration, imports, and one or more named schemas -data SchemaFile = - SchemaFile { - schemaFileNamespace :: Namespace, - schemaFilePackage :: (Maybe Package), - schemaFileImports :: [QualifiedName], - schemaFileSchemas :: [NamedSchema]} - deriving (Eq, Ord, Read, Show) - -_SchemaFile = Core.Name "hydra.pegasus.pdl.SchemaFile" - -_SchemaFile_namespace = Core.Name "namespace" - -_SchemaFile_package = Core.Name "package" - -_SchemaFile_imports = Core.Name "imports" - -_SchemaFile_schemas = Core.Name "schemas" - --- | Note: annotations are only available for aliased members -data UnionMember = - UnionMember { - unionMemberAlias :: (Maybe FieldName), - unionMemberValue :: Schema, - unionMemberAnnotations :: Annotations} - deriving (Eq, Ord, Read, Show) - -_UnionMember = Core.Name "hydra.pegasus.pdl.UnionMember" - -_UnionMember_alias = Core.Name "alias" - -_UnionMember_value = Core.Name "value" - -_UnionMember_annotations = Core.Name "annotations" - --- | Note: unions are not allowed as member types of other unions -newtype UnionSchema = - UnionSchema { - unUnionSchema :: [UnionMember]} - deriving (Eq, Ord, Read, Show) - -_UnionSchema = Core.Name "hydra.pegasus.pdl.UnionSchema" diff --git a/src/main/haskell/Hydra/Pegasus/Serde.hs b/src/main/haskell/Hydra/Pegasus/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Pegasus/Serde.hs +++ /dev/null @@ -1,194 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Serialization functions for converting Pegasus PDL AST to abstract expressions - -module Hydra.Pegasus.Serde 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.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Pegasus.Pdl as Pdl -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Convert PDL annotations to an optional expression (doc comment) -annotationsToExpr :: Pdl.Annotations -> Maybe Ast.Expr -annotationsToExpr anns = - - let d = Pdl.annotationsDoc anns - in (Optionals.map (\s -> Serialization.cst (Formatting.javaStyleComment s)) d) - --- | Convert a PDL enum field to an expression -enumFieldToExpr :: Pdl.EnumField -> Ast.Expr -enumFieldToExpr ef = - - let name = Pdl.unEnumFieldName (Pdl.enumFieldName ef) - anns = Pdl.enumFieldAnnotations ef - in (withAnnotations anns (Serialization.cst name)) - --- | Convert a qualified name to an import expression -importToExpr :: Pdl.QualifiedName -> Ast.Expr -importToExpr qn = - Serialization.spaceSep [ - Serialization.cst "import", - (qualifiedNameToExpr qn)] - --- | Convert a named schema to an expression -namedSchemaToExpr :: Pdl.NamedSchema -> Ast.Expr -namedSchemaToExpr ns = - - let qn = Pdl.namedSchemaQualifiedName ns - t = Pdl.namedSchemaType ns - anns = Pdl.namedSchemaAnnotations ns - in (withAnnotations anns (case t of - Pdl.NamedSchemaTypeRecord v0 -> - let fields = Pdl.recordSchemaFields v0 - in (Serialization.spaceSep [ - Serialization.cst "record", - (qualifiedNameToExpr qn), - (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle (Lists.map recordFieldToExpr fields))]) - Pdl.NamedSchemaTypeEnum v0 -> - let fields = Pdl.enumSchemaFields v0 - in (Serialization.spaceSep [ - Serialization.cst "enum", - (qualifiedNameToExpr qn), - (Serialization.curlyBracesList Nothing Serialization.fullBlockStyle (Lists.map enumFieldToExpr fields))]) - Pdl.NamedSchemaTypeTyperef v0 -> Serialization.spaceSep [ - Serialization.cst "typeref", - (qualifiedNameToExpr qn), - (Serialization.cst "="), - (schemaToExpr v0)])) - --- | Convert a primitive type to an expression -primitiveTypeToExpr :: Pdl.PrimitiveType -> Ast.Expr -primitiveTypeToExpr pt = - Serialization.cst (case pt of - Pdl.PrimitiveTypeBoolean -> "boolean" - Pdl.PrimitiveTypeBytes -> "bytes" - Pdl.PrimitiveTypeDouble -> "double" - Pdl.PrimitiveTypeFloat -> "float" - Pdl.PrimitiveTypeInt -> "int" - Pdl.PrimitiveTypeLong -> "long" - Pdl.PrimitiveTypeString -> "string") - --- | Convert a qualified name to an expression -qualifiedNameToExpr :: Pdl.QualifiedName -> Ast.Expr -qualifiedNameToExpr qn = - - let name = Pdl.unName (Pdl.qualifiedNameName qn) - ns = Pdl.qualifiedNameNamespace qn - parts = - Optionals.givens [ - Optionals.map (\n -> Pdl.unNamespace n) ns, - (Optionals.given name)] - in (Serialization.cst (Strings.join "." parts)) - --- | Convert a record field to an expression -recordFieldToExpr :: Pdl.RecordField -> Ast.Expr -recordFieldToExpr rf = - - let name = Pdl.unFieldName (Pdl.recordFieldName rf) - schema = Pdl.recordFieldValue rf - optional = Pdl.recordFieldOptional rf - anns = Pdl.recordFieldAnnotations rf - in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ - Optionals.given (Serialization.cst (Strings.concat2 name ":")), - (Logic.ifElse optional (Optionals.given (Serialization.cst "optional")) Nothing), - (Optionals.given (schemaToExpr schema))]))) - --- | Convert a schema file to an expression -schemaFileToExpr :: Pdl.SchemaFile -> Ast.Expr -schemaFileToExpr sf = - - let ns = Pdl.unNamespace (Pdl.schemaFileNamespace sf) - pkg = Pdl.schemaFilePackage sf - imports = Pdl.schemaFileImports sf - schemas = Pdl.schemaFileSchemas sf - namespaceSec = - Optionals.given (Serialization.spaceSep [ - Serialization.cst "namespace", - (Serialization.cst ns)]) - packageSec = - Optionals.map (\p -> Serialization.spaceSep [ - Serialization.cst "package", - (Serialization.cst (Pdl.unPackage p))]) pkg - importsSec = - Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) - schemaSecs = Lists.map (\s -> Optionals.given (namedSchemaToExpr s)) schemas - in (Serialization.doubleNewlineSep (Optionals.givens (Lists.concat [ - [ - namespaceSec, - packageSec, - importsSec], - schemaSecs]))) - --- | Convert a schema to an expression -schemaToExpr :: Pdl.Schema -> Ast.Expr -schemaToExpr schema = - case schema of - Pdl.SchemaArray v0 -> Serialization.noSep [ - Serialization.cst "array", - (Serialization.bracketList Serialization.inlineStyle [ - schemaToExpr v0])] - Pdl.SchemaMap v0 -> Serialization.noSep [ - Serialization.cst "map", - (Serialization.bracketList Serialization.inlineStyle [ - Serialization.cst "string", - (schemaToExpr v0)])] - Pdl.SchemaNamed v0 -> qualifiedNameToExpr v0 - Pdl.SchemaNull -> Serialization.cst "null" - Pdl.SchemaPrimitive v0 -> primitiveTypeToExpr v0 - Pdl.SchemaUnion v0 -> Serialization.noSep [ - Serialization.cst "union", - (Serialization.bracketList Serialization.fullBlockStyle (Lists.map unionMemberToExpr (Pdl.unUnionSchema v0)))] - --- | Convert a union member to an expression -unionMemberToExpr :: Pdl.UnionMember -> Ast.Expr -unionMemberToExpr um = - - let alias = Pdl.unionMemberAlias um - schema = Pdl.unionMemberValue um - anns = Pdl.unionMemberAnnotations um - in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ - Optionals.map (\fn -> Serialization.cst (Strings.concat2 (Pdl.unFieldName fn) ":")) alias, - (Optionals.given (schemaToExpr schema))]))) - --- | Prepend annotations (doc comment) to an expression -withAnnotations :: Pdl.Annotations -> Ast.Expr -> Ast.Expr -withAnnotations anns expr = - Serialization.newlineSep (Optionals.givens [ - annotationsToExpr anns, - (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Protobuf/Any.hs b/src/main/haskell/Hydra/Protobuf/Any.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Any.hs +++ /dev/null @@ -1,26 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/any.proto - -module Hydra.Protobuf.Any where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.ByteString as B - --- | `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. -data Any = - Any { - -- | A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. - anyTypeUrl :: String, - -- | Must be a valid serialized protocol buffer of the above specified type. - anyValue :: B.ByteString} - deriving (Eq, Ord, Read, Show) - -_Any = Core.Name "hydra.protobuf.any.Any" - -_Any_typeUrl = Core.Name "typeUrl" - -_Any_value = Core.Name "value" diff --git a/src/main/haskell/Hydra/Protobuf/Coder.hs b/src/main/haskell/Hydra/Protobuf/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Coder.hs +++ /dev/null @@ -1,586 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Protobuf code generator: converts Hydra modules to Protocol Buffers v3 definitions - -module Hydra.Protobuf.Coder where - -import qualified Hydra.Adapt as Adapt -import qualified Hydra.Analysis as Analysis -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as DecodeCore -import qualified Hydra.Docs as Docs -import qualified Hydra.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as ExtractCore -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -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.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Math as Math -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Predicates as Predicates -import qualified Hydra.Print.Core as PrintCore -import qualified Hydra.Print.Errors as PrintErrors -import qualified Hydra.Protobuf.Environment as ProtobufEnvironment -import qualified Hydra.Protobuf.Language as Language -import qualified Hydra.Protobuf.Proto3 as Proto3 -import qualified Hydra.Protobuf.Serde as Serde -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variables as Variables -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M -import qualified Data.Set as S - --- | Collect all structural type references (Either, Pair) from a list of types -collectStructuralTypes :: [Core.Type] -> S.Set ProtobufEnvironment.StructuralTypeRef -collectStructuralTypes types = - Lists.foldl (\acc -> \t -> Sets.union acc (collectStructuralTypesFromType t)) Sets.empty types - --- | Collect structural type references from a single type -collectStructuralTypesFromType :: Core.Type -> S.Set ProtobufEnvironment.StructuralTypeRef -collectStructuralTypesFromType typ = - Rewriting.foldOverType Coders.TraversalOrderPre (\acc -> \t -> - let st = simplifyType t - in case st of - Core.TypeEither v0 -> Sets.insert (ProtobufEnvironment.StructuralTypeRefEither (Core.eitherTypeLeft v0, (Core.eitherTypeRight v0))) acc - Core.TypePair v0 -> Sets.insert (ProtobufEnvironment.StructuralTypeRefPair (Core.pairTypeFirst v0, (Core.pairTypeSecond v0))) acc - _ -> acc) Sets.empty typ - --- | Construct a Protobuf file from a Hydra module and its type definitions -constructModule :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.Module -> [Packaging.TypeDefinition] -> Either Errors.Error Proto3.ProtoFile -constructModule cx g mod typeDefs = - - let ns_ = Packaging.moduleName mod - desc = Optionals.bind (Packaging.moduleMetadata mod) (\em -> Packaging.entityMetadataDescription em) - toDef = - \td -> - let name = Packaging.typeDefinitionName td - typ = Core.typeSchemeBody (Packaging.typeDefinitionBody td) - encodeDefEither = \n -> \t -> encodeDefinition cx g ns_ n t - flatTyp = flattenType typ - enc = encodeDefEither name - in case (Strip.deannotateType flatTyp) of - Core.TypeVariable _ -> enc flatTyp - _ -> Eithers.bind (Adapt.adaptTypeForLanguage Language.protobufLanguage flatTyp) (\adaptedType -> enc adaptedType) - types = Lists.map (\td -> Core.typeSchemeBody (Packaging.typeDefinitionBody td)) typeDefs - structRefs = collectStructuralTypes types - javaOptions = - [ - Proto3.Option { - Proto3.optionName = javaMultipleFilesOptionName, - Proto3.optionValue = (Proto3.ValueBoolean True)}, - Proto3.Option { - Proto3.optionName = javaPackageOptionName, - Proto3.optionValue = (Proto3.ValueString (Proto3.unPackageName (namespaceToPackageName ns_)))}] - descOption = - Proto3.Option { - Proto3.optionName = Serde.descriptionOptionName, - Proto3.optionValue = (Proto3.ValueString (Strings.concat2 (Optionals.match desc "" (\d -> Strings.concat2 d "\n\n")) Constants.warningAutoGeneratedFile))} - checkFieldType_wrapper = - \typ -> case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> case (Strip.deannotateType v0) of - Core.TypeLiteral _ -> True - _ -> False - _ -> False - checkFieldType_empty = \typ -> Predicates.isUnitType typ - checkFields = - \checkType -> \checkFieldType -> \ts -> Lists.foldl (\b -> \t -> Logic.or b (Rewriting.foldOverType Coders.TraversalOrderPre (\b2 -> \t2 -> Logic.or b2 ( - let checkResult = checkType t2 - in (Optionals.match checkResult (case t2 of - Core.TypeRecord v0 -> Lists.foldl (\b3 -> \f -> Logic.or b3 (checkFieldType (Strip.deannotateType (Core.fieldTypeType f)))) False v0 - Core.TypeUnion v0 -> Lists.foldl (\b3 -> \f -> Logic.or b3 (checkFieldType (Strip.deannotateType (Core.fieldTypeType f)))) False v0 - _ -> False) (\b3 -> b3)))) False t)) False ts - wrapperImport = - Logic.ifElse (checkFields (\_ -> Nothing) checkFieldType_wrapper types) [ - Proto3.FileReference "google/protobuf/wrappers.proto"] [] - emptyCheckType = \typ -> Logic.ifElse (isEnumDefinition typ) (Just False) Nothing - emptyImport = - Logic.ifElse (checkFields emptyCheckType checkFieldType_empty types) [ - Proto3.FileReference "google/protobuf/empty.proto"] [] - in (Eithers.bind (Analysis.moduleDependencyModuleNames (ProtobufEnvironment.encoderStateContext cx) g True False False False mod) (\schemaImports -> Eithers.bind (Eithers.mapList toDef typeDefs) (\definitions -> - let schemaImportList = Lists.map (\n -> namespaceToFileReference n) (Sets.toList schemaImports) - in (Eithers.bind (mapAccumResult (\cx0 -> \ref -> generateStructuralTypeMessage cx0 g ns_ ref) cx (Sets.toList structRefs)) (\helperResult -> - let helperDefs = Pairs.first helperResult - in (Right (Proto3.ProtoFile { - Proto3.protoFilePackage = (namespaceToPackageName ns_), - Proto3.protoFileImports = (Lists.concat [ - schemaImportList, - wrapperImport, - emptyImport]), - Proto3.protoFileTypes = (Lists.concat [ - helperDefs, - definitions]), - Proto3.protoFileOptions = (Lists.cons descOption javaOptions)}))))))) - --- | Encode a Hydra type as a Protobuf definition -encodeDefinition :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> Core.Name -> Core.Type -> Either Errors.Error Proto3.Definition -encodeDefinition cx g localNs name typ = - - let cx1 = - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), - ProtobufEnvironment.encoderStateFieldIndex = 0} - cx2 = - Pairs.second ( - ProtobufEnvironment.encoderStateFieldIndex cx1, - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx1), - ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx1) 1)}) - toEitherString = \result -> result - encode = - \cx0 -> \options -> \t -> case (simplifyType t) of - Core.TypeRecord v0 -> Eithers.map (\md -> Proto3.DefinitionMessage md) (toEitherString (encodeRecordType cx0 g localNs options name v0)) - Core.TypeUnion v0 -> Logic.ifElse (isEnumDefinition t) (Eithers.map (\ed -> Proto3.DefinitionEnum ed) (toEitherString (encodeEnumDefinition cx0 g options name v0))) (encode cx0 options (Rewriting.wrapTypeToRecord (Core.TypeUnion v0))) - _ -> encode cx0 options (Rewriting.wrapTypeToRecord t) - in (Eithers.bind (toEitherString (findOptions cx g typ)) (\options -> encode cx2 options typ)) - --- | Encode a Hydra union type as a Protobuf enum definition -encodeEnumDefinition :: ProtobufEnvironment.EncoderState -> Graph.Graph -> [Proto3.Option] -> Core.Name -> [Core.FieldType] -> Either Errors.Error Proto3.EnumDefinition -encodeEnumDefinition cx g options tname fts = - - let unspecifiedField = - Proto3.EnumValue { - Proto3.enumValueName = (encodeEnumValueName tname (Core.Name "unspecified")), - Proto3.enumValueNumber = 0, - Proto3.enumValueOptions = []} - encodeEnumField = - \field -> \idx -> - let fname = Core.fieldTypeName field - ftype = Core.fieldTypeType field - in (Eithers.bind (findOptions cx g ftype) (\opts -> Right (Proto3.EnumValue { - Proto3.enumValueName = (encodeEnumValueName tname fname), - Proto3.enumValueNumber = idx, - Proto3.enumValueOptions = opts}))) - indices = Math.range 1 (Math.add (Lists.length fts) 1) - in (Eithers.bind (Eithers.mapList (\p -> encodeEnumField (Pairs.first p) (Pairs.second p)) (Lists.zip fts indices)) (\values -> Right (Proto3.EnumDefinition { - Proto3.enumDefinitionName = (encodeTypeName tname), - Proto3.enumDefinitionValues = (Lists.cons unspecifiedField values), - Proto3.enumDefinitionOptions = options}))) - --- | Encode an enum value name from type name and field name -encodeEnumValueName :: Core.Name -> Core.Name -> Proto3.EnumValueName -encodeEnumValueName tname fname = - - let prefix = Formatting.nonAlnumToUnderscores (Formatting.convertCaseCamelToUpperSnake (Names.localNameOf tname)) - suffix = Formatting.nonAlnumToUnderscores (Formatting.convertCaseCamelToUpperSnake (Core.unName fname)) - in (Proto3.EnumValueName (Strings.concat [ - prefix, - "_", - suffix])) - --- | Encode a field name, optionally preserving the original case -encodeFieldName :: Bool -> Core.Name -> Proto3.FieldName -encodeFieldName preserve name = - Proto3.FieldName (Logic.ifElse preserve (Core.unName name) (Formatting.convertCaseCamelToLowerSnake (Core.unName name))) - --- | Encode a Hydra field type as a Protobuf field -encodeFieldType :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> Core.FieldType -> Either Errors.Error (Proto3.Field, ProtobufEnvironment.EncoderState) -encodeFieldType cx g localNs ft = - - let fname = Core.fieldTypeName ft - ftype = Core.fieldTypeType ft - encodeType_ = - \cx0 -> \g0 -> \ns0 -> \typ -> case (simplifyType typ) of - Core.TypeEither v0 -> - let ref = ProtobufEnvironment.StructuralTypeRefEither (Core.eitherTypeLeft v0, (Core.eitherTypeRight v0)) - in (Right (Proto3.FieldTypeSimple (Proto3.SimpleTypeReference (structuralTypeName ns0 ref)))) - Core.TypePair v0 -> - let ref = ProtobufEnvironment.StructuralTypeRefPair (Core.pairTypeFirst v0, (Core.pairTypeSecond v0)) - in (Right (Proto3.FieldTypeSimple (Proto3.SimpleTypeReference (structuralTypeName ns0 ref)))) - Core.TypeList v0 -> Eithers.map (\st -> Proto3.FieldTypeRepeated st) (encodeSimpleType_ cx0 g0 ns0 True v0) - Core.TypeSet v0 -> Eithers.map (\st -> Proto3.FieldTypeRepeated st) (encodeSimpleType_ cx0 g0 ns0 True v0) - Core.TypeMap v0 -> Eithers.bind (encodeSimpleType_ cx0 g0 ns0 False (Core.mapTypeKeys v0)) (\kt -> Eithers.bind (encodeSimpleType_ cx0 g0 ns0 True (Core.mapTypeValues v0)) (\vt -> Right (Proto3.FieldTypeMap (Proto3.MapType { - Proto3.mapTypeKeys = kt, - Proto3.mapTypeValues = vt})))) - Core.TypeOptional v0 -> case (Strip.deannotateType v0) of - Core.TypeLiteral v1 -> Eithers.map (\st -> Proto3.FieldTypeSimple st) (encodeScalarTypeWrapped cx0 v1) - _ -> encodeType_ cx0 g0 ns0 v0 - Core.TypeUnion v0 -> Eithers.bind (mapAccumResult (\cx_ -> \f -> encodeFieldType cx_ g0 ns0 f) cx0 v0) (\pfields -> - let fields_ = Pairs.first pfields - in (Right (Proto3.FieldTypeOneof fields_))) - _ -> Eithers.map (\st -> Proto3.FieldTypeSimple st) (encodeSimpleType_ cx0 g0 ns0 True typ) - encodeSimpleType_ = - \cx0 -> \g0 -> \ns0 -> \noms -> \typ -> - let forNominal = \name -> Right (Proto3.SimpleTypeReference (encodeTypeReference ns0 name)) - in case (simplifyType typ) of - Core.TypeLiteral v0 -> Eithers.map (\st -> Proto3.SimpleTypeScalar st) (encodeScalarType cx0 v0) - Core.TypeRecord _ -> unexpectedE cx0 "named type reference" "anonymous record type" - Core.TypeUnion _ -> unexpectedE cx0 "named type reference" "anonymous union type" - Core.TypeUnit -> Right (Proto3.SimpleTypeReference (Proto3.TypeName "google.protobuf.Empty")) - Core.TypeVariable v0 -> Logic.ifElse noms (forNominal v0) (Eithers.bind (Lexical.requireBinding g0 v0) (\el -> - let term = Core.bindingTerm el - in (Eithers.bind (Eithers.bimap (\de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError de))) (\t -> t) (DecodeCore.type_ g0 term)) (\resolvedTyp -> encodeSimpleType_ cx0 g0 ns0 noms resolvedTyp)))) - _ -> unexpectedE cx0 "simple type" (PrintCore.type_ (Strip.removeTypeAnnotations typ)) - in (Eithers.bind (findOptions cx g ftype) (\options -> Eithers.bind (encodeType_ cx g localNs ftype) (\ft_ -> - let idxPair = - ( - ProtobufEnvironment.encoderStateFieldIndex cx, - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), - ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx) 1)}) - idx = Pairs.first idxPair - cx1 = Pairs.second idxPair - in (Eithers.bind (readBooleanAnnotation cx g Constants.keyPreserveFieldName ftype) (\preserve -> Right ( - Proto3.Field { - Proto3.fieldName = (encodeFieldName preserve fname), - Proto3.fieldJsonName = Nothing, - Proto3.fieldType = ft_, - Proto3.fieldNumber = idx, - Proto3.fieldOptions = options}, - cx1)))))) - --- | Encode a Hydra record type as a Protobuf message definition -encodeRecordType :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Packaging.ModuleName -> [Proto3.Option] -> Core.Name -> [Core.FieldType] -> Either Errors.Error Proto3.MessageDefinition -encodeRecordType cx g localNs options tname fts = - Eithers.bind (mapAccumResult (\cx_ -> \f -> encodeFieldType cx_ g localNs f) cx fts) (\result -> - let pfields = Pairs.first result - in (Right (Proto3.MessageDefinition { - Proto3.messageDefinitionName = (encodeTypeName tname), - Proto3.messageDefinitionFields = pfields, - Proto3.messageDefinitionOptions = options}))) - --- | Encode a Hydra literal type as a Protobuf scalar type -encodeScalarType :: t0 -> Core.LiteralType -> Either Errors.Error Proto3.ScalarType -encodeScalarType cx lt = - case lt of - Core.LiteralTypeBinary -> Right Proto3.ScalarTypeBytes - Core.LiteralTypeBoolean -> Right Proto3.ScalarTypeBool - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat32 -> Right Proto3.ScalarTypeFloat - Core.FloatTypeFloat64 -> Right Proto3.ScalarTypeDouble - _ -> unexpectedE cx "32-bit or 64-bit floating-point type" (PrintCore.floatType v0) - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeInt32 -> Right Proto3.ScalarTypeInt32 - Core.IntegerTypeInt64 -> Right Proto3.ScalarTypeInt64 - Core.IntegerTypeUint32 -> Right Proto3.ScalarTypeUint32 - Core.IntegerTypeUint64 -> Right Proto3.ScalarTypeUint64 - _ -> unexpectedE cx "32-bit or 64-bit integer type" (PrintCore.integerType v0) - Core.LiteralTypeString -> Right Proto3.ScalarTypeString - _ -> unexpectedE cx "supported literal type" (PrintCore.literalType lt) - --- | Encode a Hydra literal type as a wrapped Protobuf type (for optional scalars) -encodeScalarTypeWrapped :: t0 -> Core.LiteralType -> Either Errors.Error Proto3.SimpleType -encodeScalarTypeWrapped cx lt = - - let toType = - \label -> Right (Proto3.SimpleTypeReference (Proto3.TypeName (Strings.concat [ - "google.protobuf.", - label, - "Value"]))) - in case lt of - Core.LiteralTypeBinary -> toType "Bytes" - Core.LiteralTypeBoolean -> toType "Bool" - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat32 -> toType "Float" - Core.FloatTypeFloat64 -> toType "Double" - _ -> unexpectedE cx "32-bit or 64-bit floating-point type" (PrintCore.floatType v0) - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeInt32 -> toType "Int32" - Core.IntegerTypeInt64 -> toType "Int64" - Core.IntegerTypeUint32 -> toType "UInt32" - Core.IntegerTypeUint64 -> toType "UInt64" - _ -> unexpectedE cx "32-bit or 64-bit integer type" (PrintCore.integerType v0) - Core.LiteralTypeString -> toType "String" - _ -> unexpectedE cx "supported literal type" (PrintCore.literalType lt) - --- | Encode a simple type for helper message fields -encodeSimpleTypeForHelper :: t0 -> Packaging.ModuleName -> Core.Type -> Either Errors.Error Proto3.SimpleType -encodeSimpleTypeForHelper cx localNs typ = - - let forNominal = \name -> Right (Proto3.SimpleTypeReference (encodeTypeReference localNs name)) - in case (simplifyType typ) of - Core.TypeLiteral v0 -> Eithers.map (\st -> Proto3.SimpleTypeScalar st) (encodeScalarType cx v0) - Core.TypeRecord _ -> unexpectedE cx "named type reference" "anonymous record type" - Core.TypeUnion _ -> unexpectedE cx "named type reference" "anonymous union type" - Core.TypeUnit -> Right (Proto3.SimpleTypeReference (Proto3.TypeName "google.protobuf.Empty")) - Core.TypeVariable v0 -> forNominal v0 - _ -> unexpectedE cx "simple type in structural type helper" (PrintCore.type_ (Strip.removeTypeAnnotations typ)) - --- | Encode a Hydra type name as a Protobuf type name -encodeTypeName :: Core.Name -> Proto3.TypeName -encodeTypeName name = Proto3.TypeName (Names.localNameOf name) - --- | Encode a Hydra name as a Protobuf type reference -encodeTypeReference :: Packaging.ModuleName -> Core.Name -> Proto3.TypeName -encodeTypeReference localNs name = - - let qn = Names.qualifyName name - local = Util.qualifiedNameLocal qn - ns_ = Util.qualifiedNameModuleName qn - localNsParts = Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName localNs))) - in (Proto3.TypeName (Optionals.match ns_ local (\nsVal -> - let nsParts = Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName nsVal))) - in (Logic.ifElse (Equality.equal nsParts localNsParts) local (Strings.join "." (Lists.concat [ - nsParts, - [ - local]])))))) - --- | Construct a Left error result from an error message, ignoring the encoder state -err :: t0 -> String -> Either Errors.Error t1 -err cx msg = Left (Errors.ErrorOther (Errors.OtherError msg)) - --- | Find Protobuf options for a type (description and deprecated) -findOptions :: ProtobufEnvironment.EncoderState -> Graph.Graph -> Core.Type -> Either Errors.Error [Proto3.Option] -findOptions cx g typ = - Eithers.bind (Annotations.getTypeDescription (ProtobufEnvironment.encoderStateContext cx) g typ) (\mdesc -> Eithers.bind (readBooleanAnnotation cx g Constants.keyDeprecated typ) (\bdep -> - let mdescAnn = - Optionals.map (\desc_ -> Proto3.Option { - Proto3.optionName = Serde.descriptionOptionName, - Proto3.optionValue = (Proto3.ValueString desc_)}) mdesc - mdepAnn = - Logic.ifElse bdep (Just (Proto3.Option { - Proto3.optionName = "deprecated", - Proto3.optionValue = (Proto3.ValueBoolean True)})) Nothing - in (Right (Optionals.givens [ - mdescAnn, - mdepAnn])))) - --- | Eliminate type lambdas and type applications, replacing type variables with the string type -flattenType :: Core.Type -> Core.Type -flattenType typ = - Rewriting.rewriteType (\recurse -> \t -> case t of - Core.TypeForall v0 -> recurse (Variables.replaceFreeTypeVariable (Core.forallTypeParameter v0) (Core.TypeLiteral Core.LiteralTypeString) (Core.forallTypeBody v0)) - Core.TypeApplication v0 -> recurse (Core.applicationTypeFunction v0) - _ -> recurse t) typ - --- | Convert an Either String result into an Either Error result -fromEitherString :: t0 -> Either String t1 -> Either Errors.Error t1 -fromEitherString cx e = Eithers.bimap (\msg -> Errors.ErrorOther (Errors.OtherError msg)) (\a -> a) e - --- | Generate a helper message definition for a structural type -generateStructuralTypeMessage :: ProtobufEnvironment.EncoderState -> t0 -> Packaging.ModuleName -> ProtobufEnvironment.StructuralTypeRef -> Either Errors.Error (Proto3.Definition, ProtobufEnvironment.EncoderState) -generateStructuralTypeMessage cx g localNs ref = - - let cx1 = - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx), - ProtobufEnvironment.encoderStateFieldIndex = 0} - cx2 = - Pairs.second ( - ProtobufEnvironment.encoderStateFieldIndex cx1, - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx1), - ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx1) 1)}) - makeField = - \cx0 -> \fname -> \ftyp -> Eithers.bind (encodeSimpleTypeForHelper cx0 localNs ftyp) (\ft -> - let idxPair = - ( - ProtobufEnvironment.encoderStateFieldIndex cx0, - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = (ProtobufEnvironment.encoderStateContext cx0), - ProtobufEnvironment.encoderStateFieldIndex = (Math.add (ProtobufEnvironment.encoderStateFieldIndex cx0) 1)}) - idx = Pairs.first idxPair - cx1_ = Pairs.second idxPair - in (Right ( - Proto3.Field { - Proto3.fieldName = (Proto3.FieldName fname), - Proto3.fieldJsonName = Nothing, - Proto3.fieldType = (Proto3.FieldTypeSimple ft), - Proto3.fieldNumber = idx, - Proto3.fieldOptions = []}, - cx1_))) - in case ref of - ProtobufEnvironment.StructuralTypeRefEither v0 -> - let lt = Pairs.first v0 - rt = Pairs.second v0 - in (Eithers.bind (makeField cx2 "left" lt) (\leftResult -> - let leftField = Pairs.first leftResult - cx3 = Pairs.second leftResult - in (Eithers.bind (makeField cx3 "right" rt) (\rightResult -> - let rightField = Pairs.first rightResult - cx4 = Pairs.second rightResult - in (Right ( - Proto3.DefinitionMessage (Proto3.MessageDefinition { - Proto3.messageDefinitionName = (structuralTypeName localNs ref), - Proto3.messageDefinitionFields = [ - leftField, - rightField], - Proto3.messageDefinitionOptions = []}), - cx4)))))) - ProtobufEnvironment.StructuralTypeRefPair v0 -> - let ft = Pairs.first v0 - st = Pairs.second v0 - in (Eithers.bind (makeField cx2 "first" ft) (\firstResult -> - let firstField = Pairs.first firstResult - cx3 = Pairs.second firstResult - in (Eithers.bind (makeField cx3 "second" st) (\secondResult -> - let secondField = Pairs.first secondResult - cx4 = Pairs.second secondResult - in (Right ( - Proto3.DefinitionMessage (Proto3.MessageDefinition { - Proto3.messageDefinitionName = (structuralTypeName localNs ref), - Proto3.messageDefinitionFields = [ - firstField, - secondField], - Proto3.messageDefinitionOptions = []}), - cx4)))))) - --- | Check if a type is an enum definition -isEnumDefinition :: Core.Type -> Bool -isEnumDefinition typ = - case (simplifyType typ) of - Core.TypeUnion v0 -> isEnumFields v0 - _ -> False - --- | Check if all fields are unit types (i.e., this is an enum) -isEnumFields :: [Core.FieldType] -> Bool -isEnumFields fts = - Lists.foldl (\b -> \f -> Logic.and b (Predicates.isUnitType (simplifyType (Core.fieldTypeType f)))) True fts - --- | The name of the Protobuf java_multiple_files option -javaMultipleFilesOptionName :: String -javaMultipleFilesOptionName = "java_multiple_files" - --- | The name of the Protobuf java_package option -javaPackageOptionName :: String -javaPackageOptionName = "java_package" - --- | Annotation key under which the assigned Protobuf field index is recorded -keyProtoFieldIndex :: Core.Name -keyProtoFieldIndex = Core.Name "proto_field_index" - --- | Thread context through a list, accumulating results -mapAccumResult :: (t0 -> t1 -> Either t2 (t3, t0)) -> t0 -> [t1] -> Either t2 ([t3], t0) -mapAccumResult f cx0 xs = - Lists.foldl (\accE -> \x -> Eithers.bind accE (\accPair -> - let bs = Pairs.first accPair - cxN = Pairs.second accPair - in (Eithers.map (\resultPair -> ( - Lists.concat [ - bs, - [ - Pairs.first resultPair]], - (Pairs.second resultPair))) (f cxN x)))) (Right ([], cx0)) xs - --- | Convert a Hydra module to Protocol Buffers v3 source files -moduleToProtobuf :: Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map String String) -moduleToProtobuf mod defs cx g = - - let ns_ = Packaging.moduleName mod - partitioned = Environment.partitionDefinitions defs - typeDefs = Pairs.first partitioned - es = - ProtobufEnvironment.EncoderState { - ProtobufEnvironment.encoderStateContext = cx, - ProtobufEnvironment.encoderStateFieldIndex = 0} - in (Eithers.bind (constructModule es g mod typeDefs) (\pfile -> - let content = Serialization.printExpr (Serialization.parenthesize (Serde.protoFileToExpr pfile)) - path = Proto3.unFileReference (namespaceToFileReference ns_) - in (Right (Maps.singleton path content)))) - --- | Convert a Hydra namespace to a Protobuf file reference -namespaceToFileReference :: Packaging.ModuleName -> Proto3.FileReference -namespaceToFileReference ns_ = - - let pns = - Strings.join "/" (Lists.map (\s -> Formatting.convertCaseCamelToLowerSnake s) (Strings.splitOn "." (Packaging.unModuleName ns_))) - in (Proto3.FileReference (Strings.concat2 pns ".proto")) - --- | Convert a Hydra namespace to a Protobuf package name -namespaceToPackageName :: Packaging.ModuleName -> Proto3.PackageName -namespaceToPackageName ns_ = - Proto3.PackageName (Strings.join "." (Lists.map (\s -> Formatting.convertCaseCamelToLowerSnake s) (Optionals.withDefault [] (Lists.init (Strings.splitOn "." (Packaging.unModuleName ns_)))))) - --- | Read a boolean annotation from a type -readBooleanAnnotation :: t0 -> Graph.Graph -> Core.Name -> Core.Type -> Either Errors.Error Bool -readBooleanAnnotation cx g key typ = - Optionals.match (Maps.lookup key (Annotations.typeAnnotationInternal typ)) (Right False) (\term -> ExtractCore.boolean g term) - --- | Simplify a type by removing annotations and unwrapping newtypes -simplifyType :: Core.Type -> Core.Type -simplifyType typ = - case (Strip.deannotateType typ) of - Core.TypeWrap v0 -> simplifyType v0 - _ -> Strip.deannotateType typ - --- | Generate a message name for a structural type reference -structuralTypeName :: t0 -> ProtobufEnvironment.StructuralTypeRef -> Proto3.TypeName -structuralTypeName localNs ref = - - let typeSuffix = - \typ -> - let st = simplifyType typ - in case st of - Core.TypeLiteral v0 -> case v0 of - Core.LiteralTypeBinary -> "bytes" - Core.LiteralTypeBoolean -> "bool" - Core.LiteralTypeFloat v1 -> case v1 of - Core.FloatTypeFloat32 -> "float" - Core.FloatTypeFloat64 -> "double" - _ -> "float" - Core.LiteralTypeInteger v1 -> case v1 of - Core.IntegerTypeInt32 -> "int32" - Core.IntegerTypeInt64 -> "int64" - Core.IntegerTypeUint32 -> "uint32" - Core.IntegerTypeUint64 -> "uint64" - _ -> "int64" - Core.LiteralTypeString -> "string" - _ -> "value" - Core.TypeRecord _ -> "record" - Core.TypeUnion _ -> "union" - Core.TypeVariable v0 -> Names.localNameOf v0 - Core.TypeUnit -> "unit" - Core.TypeList _ -> "list" - Core.TypeSet _ -> "set" - Core.TypeMap _ -> "map" - Core.TypeOptional _ -> "optional" - _ -> "value" - in (Proto3.TypeName (case ref of - ProtobufEnvironment.StructuralTypeRefEither v0 -> Strings.concat [ - "Either_", - (typeSuffix (Pairs.first v0)), - "_", - (typeSuffix (Pairs.second v0))] - ProtobufEnvironment.StructuralTypeRefPair v0 -> Strings.concat [ - "Pair_", - (typeSuffix (Pairs.first v0)), - "_", - (typeSuffix (Pairs.second v0))])) - --- | Construct an error reporting an expected construct versus what was actually found -unexpectedE :: t0 -> String -> String -> Either Errors.Error t1 -unexpectedE cx expected found = - err cx (Strings.concat [ - "Expected ", - expected, - ", found: ", - found]) diff --git a/src/main/haskell/Hydra/Protobuf/Environment.hs b/src/main/haskell/Hydra/Protobuf/Environment.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Environment.hs +++ /dev/null @@ -1,40 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type definitions for the Protobuf code generation environment - -module Hydra.Protobuf.Environment where - -import qualified Hydra.Core as Core -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | State threaded through Protobuf encoding: inference context plus field-index counter -data EncoderState = - EncoderState { - -- | Inference context used by kernel utilities (annotations, dependency analysis) - encoderStateContext :: Typing.InferenceContext, - -- | Counter used to assign the next Protobuf field index within the current message - encoderStateFieldIndex :: Int} - deriving (Eq, Ord, Read, Show) - -_EncoderState = Core.Name "hydra.protobuf.environment.EncoderState" - -_EncoderState_context = Core.Name "context" - -_EncoderState_fieldIndex = Core.Name "fieldIndex" - --- | A reference to a structural type (Either or Pair) with its component types -data StructuralTypeRef = - -- | An Either type with left and right component types - StructuralTypeRefEither (Core.Type, Core.Type) | - -- | A Pair type with first and second component types - StructuralTypeRefPair (Core.Type, Core.Type) - deriving (Eq, Ord, Read, Show) - -_StructuralTypeRef = Core.Name "hydra.protobuf.environment.StructuralTypeRef" - -_StructuralTypeRef_either = Core.Name "either" - -_StructuralTypeRef_pair = Core.Name "pair" diff --git a/src/main/haskell/Hydra/Protobuf/Language.hs b/src/main/haskell/Hydra/Protobuf/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Language.hs +++ /dev/null @@ -1,162 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for Protobuf v3 - -module Hydra.Protobuf.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | Language constraints for Protocol Buffers v3 -protobufLanguage :: Coders.Language -protobufLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.protobuf"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "proto")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt32, - Core.IntegerTypeInt64, - Core.IntegerTypeUint32, - Core.IntegerTypeUint64] - termVariants = - Sets.fromList [ - Variants.TermVariantEither, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantPair, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantInject, - Variants.TermVariantUnit, - Variants.TermVariantWrap] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantEither, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantUnit, - Variants.TypeVariantVariable, - Variants.TypeVariantVoid, - Variants.TypeVariantWrap] - typePredicate = - \typ -> case typ of - Core.TypeMap v0 -> - let valuesType = Core.mapTypeValues v0 - stripped = Strip.deannotateType valuesType - in case stripped of - Core.TypeOptional _ -> False - _ -> True - _ -> True - --- | A set of reserved words in Protobuf -protobufReservedWords :: S.Set String -protobufReservedWords = Sets.fromList (Lists.concat [ - fieldNames]) - where - fieldNames = - [ - "case", - "class", - "data", - "default", - "deriving", - "do", - "else", - "foreign", - "if", - "import", - "in", - "infix", - "infixl", - "infixr", - "instance", - "let", - "mdo", - "module", - "newtype", - "of", - "pattern", - "proc", - "rec", - "then", - "type", - "where"] diff --git a/src/main/haskell/Hydra/Protobuf/Proto3.hs b/src/main/haskell/Hydra/Protobuf/Proto3.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Proto3.hs +++ /dev/null @@ -1,294 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for Protocol Buffers v3 enum and message types, designed as a target for transformations.This model is loosely based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/type.proto, as well as the proto3 reference documentation - -module Hydra.Protobuf.Proto3 where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | A top-level Protobuf definition, either an enum or a message type -data Definition = - DefinitionEnum EnumDefinition | - DefinitionMessage MessageDefinition - deriving (Eq, Ord, Read, Show) - -_Definition = Core.Name "hydra.protobuf.proto3.Definition" - -_Definition_enum = Core.Name "enum" - -_Definition_message = Core.Name "message" - --- | Enum type definition -data EnumDefinition = - EnumDefinition { - -- | Enum type name - enumDefinitionName :: TypeName, - -- | Enum value definitions - enumDefinitionValues :: [EnumValue], - -- | Protocol buffer options - enumDefinitionOptions :: [Option]} - deriving (Eq, Ord, Read, Show) - -_EnumDefinition = Core.Name "hydra.protobuf.proto3.EnumDefinition" - -_EnumDefinition_name = Core.Name "name" - -_EnumDefinition_values = Core.Name "values" - -_EnumDefinition_options = Core.Name "options" - --- | Enum value definition -data EnumValue = - EnumValue { - -- | Enum value name - enumValueName :: EnumValueName, - -- | Enum value number - enumValueNumber :: Int, - -- | Protocol buffer options - enumValueOptions :: [Option]} - deriving (Eq, Ord, Read, Show) - -_EnumValue = Core.Name "hydra.protobuf.proto3.EnumValue" - -_EnumValue_name = Core.Name "name" - -_EnumValue_number = Core.Name "number" - -_EnumValue_options = Core.Name "options" - --- | The name of an enum value, conventionally an upper-snake-case identifier -newtype EnumValueName = - EnumValueName { - unEnumValueName :: String} - deriving (Eq, Ord, Read, Show) - -_EnumValueName = Core.Name "hydra.protobuf.proto3.EnumValueName" - --- | A single field of a message type -data Field = - Field { - -- | The field name - fieldName :: FieldName, - -- | The field JSON name - fieldJsonName :: (Maybe String), - -- | The datatype of the field - fieldType :: FieldType, - -- | The field number - fieldNumber :: Int, - -- | The protocol buffer options - fieldOptions :: [Option]} - deriving (Eq, Ord, Read, Show) - -_Field = Core.Name "hydra.protobuf.proto3.Field" - -_Field_name = Core.Name "name" - -_Field_jsonName = Core.Name "jsonName" - -_Field_type = Core.Name "type" - -_Field_number = Core.Name "number" - -_Field_options = Core.Name "options" - --- | The name of a field -newtype FieldName = - FieldName { - unFieldName :: String} - deriving (Eq, Ord, Read, Show) - -_FieldName = Core.Name "hydra.protobuf.proto3.FieldName" - --- | The type of a message field: a map, a oneof group, a repeated field, or a simple field -data FieldType = - FieldTypeMap MapType | - FieldTypeOneof [Field] | - FieldTypeRepeated SimpleType | - FieldTypeSimple SimpleType - deriving (Eq, Ord, Read, Show) - -_FieldType = Core.Name "hydra.protobuf.proto3.FieldType" - -_FieldType_map = Core.Name "map" - -_FieldType_oneof = Core.Name "oneof" - -_FieldType_repeated = Core.Name "repeated" - -_FieldType_simple = Core.Name "simple" - --- | A path to a .proto file, as used in import statements -newtype FileReference = - FileReference { - unFileReference :: String} - deriving (Eq, Ord, Read, Show) - -_FileReference = Core.Name "hydra.protobuf.proto3.FileReference" - --- | The key and value types of a proto3 map field -data MapType = - MapType { - mapTypeKeys :: SimpleType, - mapTypeValues :: SimpleType} - deriving (Eq, Ord, Read, Show) - -_MapType = Core.Name "hydra.protobuf.proto3.MapType" - -_MapType_keys = Core.Name "keys" - -_MapType_values = Core.Name "values" - --- | A protocol buffer message type -data MessageDefinition = - MessageDefinition { - -- | The fully qualified message name - messageDefinitionName :: TypeName, - -- | The list of fields - messageDefinitionFields :: [Field], - -- | The protocol buffer options - messageDefinitionOptions :: [Option]} - deriving (Eq, Ord, Read, Show) - -_MessageDefinition = Core.Name "hydra.protobuf.proto3.MessageDefinition" - -_MessageDefinition_name = Core.Name "name" - -_MessageDefinition_fields = Core.Name "fields" - -_MessageDefinition_options = Core.Name "options" - --- | A protocol buffer option, which can be attached to a message, field, enumeration, etc -data Option = - Option { - -- | The option's name. For protobuf built-in options (options defined in descriptor.proto), this is the short name. For example, `"map_entry"`. For custom options, it should be the fully-qualified name. For example, `"google.api.http"`. - optionName :: String, - -- | The option's value - optionValue :: Value} - deriving (Eq, Ord, Read, Show) - -_Option = Core.Name "hydra.protobuf.proto3.Option" - -_Option_name = Core.Name "name" - -_Option_value = Core.Name "value" - --- | A Protobuf package name, i.e. the value of a package declaration -newtype PackageName = - PackageName { - unPackageName :: String} - deriving (Eq, Ord, Read, Show) - -_PackageName = Core.Name "hydra.protobuf.proto3.PackageName" - --- | A .proto file, usually containing one or more enum or message type definitions -data ProtoFile = - ProtoFile { - protoFilePackage :: PackageName, - protoFileImports :: [FileReference], - protoFileTypes :: [Definition], - protoFileOptions :: [Option]} - deriving (Eq, Ord, Read, Show) - -_ProtoFile = Core.Name "hydra.protobuf.proto3.ProtoFile" - -_ProtoFile_package = Core.Name "package" - -_ProtoFile_imports = Core.Name "imports" - -_ProtoFile_types = Core.Name "types" - -_ProtoFile_options = Core.Name "options" - --- | One of several Proto3 scalar types -data ScalarType = - ScalarTypeBool | - ScalarTypeBytes | - ScalarTypeDouble | - ScalarTypeFixed32 | - ScalarTypeFixed64 | - ScalarTypeFloat | - ScalarTypeInt32 | - ScalarTypeInt64 | - ScalarTypeSfixed32 | - ScalarTypeSfixed64 | - ScalarTypeSint32 | - ScalarTypeSint64 | - ScalarTypeString | - ScalarTypeUint32 | - ScalarTypeUint64 - deriving (Eq, Ord, Read, Show) - -_ScalarType = Core.Name "hydra.protobuf.proto3.ScalarType" - -_ScalarType_bool = Core.Name "bool" - -_ScalarType_bytes = Core.Name "bytes" - -_ScalarType_double = Core.Name "double" - -_ScalarType_fixed32 = Core.Name "fixed32" - -_ScalarType_fixed64 = Core.Name "fixed64" - -_ScalarType_float = Core.Name "float" - -_ScalarType_int32 = Core.Name "int32" - -_ScalarType_int64 = Core.Name "int64" - -_ScalarType_sfixed32 = Core.Name "sfixed32" - -_ScalarType_sfixed64 = Core.Name "sfixed64" - -_ScalarType_sint32 = Core.Name "sint32" - -_ScalarType_sint64 = Core.Name "sint64" - -_ScalarType_string = Core.Name "string" - -_ScalarType_uint32 = Core.Name "uint32" - -_ScalarType_uint64 = Core.Name "uint64" - --- | A scalar type or a reference to an enum type or message type -data SimpleType = - SimpleTypeReference TypeName | - SimpleTypeScalar ScalarType - deriving (Eq, Ord, Read, Show) - -_SimpleType = Core.Name "hydra.protobuf.proto3.SimpleType" - -_SimpleType_reference = Core.Name "reference" - -_SimpleType_scalar = Core.Name "scalar" - --- | The local name of an enum type or message type -newtype TypeName = - TypeName { - unTypeName :: String} - deriving (Eq, Ord, Read, Show) - -_TypeName = Core.Name "hydra.protobuf.proto3.TypeName" - --- | A reference to an enum type or message type -newtype TypeReference = - TypeReference { - unTypeReference :: String} - deriving (Eq, Ord, Read, Show) - -_TypeReference = Core.Name "hydra.protobuf.proto3.TypeReference" - --- | A scalar value -data Value = - ValueBoolean Bool | - ValueString String - deriving (Eq, Ord, Read, Show) - -_Value = Core.Name "hydra.protobuf.proto3.Value" - -_Value_boolean = Core.Name "boolean" - -_Value_string = Core.Name "string" diff --git a/src/main/haskell/Hydra/Protobuf/Serde.hs b/src/main/haskell/Hydra/Protobuf/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/Serde.hs +++ /dev/null @@ -1,294 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Serialization functions for converting Protocol Buffers v3 AST to abstract expressions - -module Hydra.Protobuf.Serde 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.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Protobuf.Proto3 as Proto3 -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Convert a definition to an expression -definitionToExpr :: Proto3.Definition -> Ast.Expr -definitionToExpr def = - case def of - Proto3.DefinitionEnum v0 -> enumDefinitionToExpr v0 - Proto3.DefinitionMessage v0 -> messageDefinitionToExpr v0 - --- | The name of the deprecated option -deprecatedOptionName :: String -deprecatedOptionName = "deprecated" - --- | A special Protobuf option name for descriptions (documentation) -descriptionOptionName :: String -descriptionOptionName = "_description" - --- | Convert an enum definition to an expression -enumDefinitionToExpr :: Proto3.EnumDefinition -> Ast.Expr -enumDefinitionToExpr ed = - - let name = Proto3.enumDefinitionName ed - values = Proto3.enumDefinitionValues ed - options = Proto3.enumDefinitionOptions ed - in (optDesc False options (Serialization.spaceSep [ - Serialization.cst "enum", - (Serialization.cst (Proto3.unTypeName name)), - (protoBlock (Lists.map enumValueToExpr values))])) - --- | Convert an enum value to an expression -enumValueToExpr :: Proto3.EnumValue -> Ast.Expr -enumValueToExpr ev = - - let name = Proto3.enumValueName ev - number = Proto3.enumValueNumber ev - options = Proto3.enumValueOptions ev - in (optDesc False options (semi (Serialization.spaceSep [ - Serialization.cst (Proto3.unEnumValueName name), - (Serialization.cst "="), - (Serialization.cst (Literals.printInt32 number))]))) - --- | Filter out internal options (those whose names start with underscore) -excludeInternalOptions :: [Proto3.Option] -> [Proto3.Option] -excludeInternalOptions opts = - Lists.filter (\opt -> Logic.not (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 (Proto3.optionName opt))) 95)) opts - --- | Convert a field option to an expression -fieldOptionToExpr :: Proto3.Option -> Ast.Expr -fieldOptionToExpr opt = - - let name = Proto3.optionName opt - value = Proto3.optionValue opt - in (Serialization.spaceSep [ - Serialization.cst name, - (Serialization.cst "="), - (valueToExpr value)]) - --- | Convert field options to an optional bracket-enclosed expression -fieldOptionsToExpr :: [Proto3.Option] -> Maybe Ast.Expr -fieldOptionsToExpr opts0 = - - let opts = excludeInternalOptions opts0 - in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.bracketList Serialization.inlineStyle (Lists.map fieldOptionToExpr opts)))) - --- | Convert a field to an expression -fieldToExpr :: Proto3.Field -> Ast.Expr -fieldToExpr f = - - let name = Proto3.fieldName f - typ = Proto3.fieldType f - num = Proto3.fieldNumber f - options = Proto3.fieldOptions f - in (optDesc False options (case typ of - Proto3.FieldTypeOneof v0 -> Serialization.spaceSep [ - Serialization.cst "oneof", - (Serialization.cst (Proto3.unFieldName name)), - (protoBlock (Lists.map fieldToExpr v0))] - Proto3.FieldTypeMap v0 -> - let kt = Proto3.mapTypeKeys v0 - vt = Proto3.mapTypeValues v0 - in (semi (Serialization.spaceSep (Optionals.givens [ - Optionals.given (fieldTypeToExpr typ), - (Optionals.given (Serialization.cst (Proto3.unFieldName name))), - (Optionals.given (Serialization.cst "=")), - (Optionals.given (Serialization.cst (Literals.printInt32 num))), - (fieldOptionsToExpr options)]))) - Proto3.FieldTypeRepeated _ -> semi (Serialization.spaceSep (Optionals.givens [ - Optionals.given (fieldTypeToExpr typ), - (Optionals.given (Serialization.cst (Proto3.unFieldName name))), - (Optionals.given (Serialization.cst "=")), - (Optionals.given (Serialization.cst (Literals.printInt32 num))), - (fieldOptionsToExpr options)])) - Proto3.FieldTypeSimple _ -> semi (Serialization.spaceSep (Optionals.givens [ - Optionals.given (fieldTypeToExpr typ), - (Optionals.given (Serialization.cst (Proto3.unFieldName name))), - (Optionals.given (Serialization.cst "=")), - (Optionals.given (Serialization.cst (Literals.printInt32 num))), - (fieldOptionsToExpr options)])))) - --- | Convert a field type to an expression -fieldTypeToExpr :: Proto3.FieldType -> Ast.Expr -fieldTypeToExpr ftyp = - case ftyp of - Proto3.FieldTypeMap v0 -> - let kt = Proto3.mapTypeKeys v0 - vt = Proto3.mapTypeValues v0 - in (Serialization.noSep [ - Serialization.cst "map", - (Serialization.angleBracesList Serialization.inlineStyle [ - simpleTypeToExpr kt, - (simpleTypeToExpr vt)])]) - Proto3.FieldTypeRepeated v0 -> Serialization.spaceSep [ - Serialization.cst "repeated", - (simpleTypeToExpr v0)] - Proto3.FieldTypeSimple v0 -> simpleTypeToExpr v0 - Proto3.FieldTypeOneof _ -> Serialization.cst "oneof" - --- | Convert a file-level option to an expression -fileOptionToExpr :: Proto3.Option -> Ast.Expr -fileOptionToExpr opt = - - let name = Proto3.optionName opt - value = Proto3.optionValue opt - in (semi (Serialization.spaceSep [ - Serialization.cst "option", - (Serialization.cst name), - (Serialization.cst "="), - (valueToExpr value)])) - --- | Convert file-level options to an optional newline-separated expression -fileOptionsToExpr :: [Proto3.Option] -> Maybe Ast.Expr -fileOptionsToExpr opts0 = - - let opts = excludeInternalOptions opts0 - in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.newlineSep (Lists.map fileOptionToExpr opts)))) - --- | Convert a file reference to an import expression -importToExpr :: Proto3.FileReference -> Ast.Expr -importToExpr ref = - semi (Serialization.spaceSep [ - Serialization.cst "import", - (Serialization.cst (Literals.printString (Proto3.unFileReference ref)))]) - --- | Convert a message definition to an expression -messageDefinitionToExpr :: Proto3.MessageDefinition -> Ast.Expr -messageDefinitionToExpr md = - - let name = Proto3.messageDefinitionName md - fields = Proto3.messageDefinitionFields md - options = Proto3.messageDefinitionOptions md - in (optDesc False options (Serialization.spaceSep [ - Serialization.cst "message", - (Serialization.cst (Proto3.unTypeName name)), - (protoBlock (Lists.map fieldToExpr fields))])) - --- | Prepend an optional description comment to an expression -optDesc :: Bool -> [Proto3.Option] -> Ast.Expr -> Ast.Expr -optDesc doubleNewline opts expr = - - let descs = Lists.filter (\opt -> Equality.equal (Proto3.optionName opt) "_description") opts - in (Optionals.match (Lists.head descs) expr (\firstDesc -> - let descValue = Proto3.optionValue firstDesc - descStr = - case descValue of - Proto3.ValueBoolean v0 -> Logic.ifElse v0 "true" "false" - Proto3.ValueString v0 -> v0 - commentLines = - Lists.map (\line -> Logic.ifElse (Equality.equal line "") "//" (Strings.concat2 "// " line)) (Formatting.lines descStr) - comment = Serialization.cst (Strings.join "\n" commentLines) - sep = - Logic.ifElse doubleNewline (Serialization.doubleNewlineSep [ - comment, - expr]) (Serialization.newlineSep [ - comment, - expr]) - in sep)) - --- | Wrap expressions in a curly-braced block with double-newline separation -protoBlock :: [Ast.Expr] -> Ast.Expr -protoBlock exprs = - Serialization.brackets Serialization.curlyBraces Serialization.fullBlockStyle (Serialization.doubleNewlineSep exprs) - --- | Convert a proto file to an expression -protoFileToExpr :: Proto3.ProtoFile -> Ast.Expr -protoFileToExpr pf = - - let pkg = Proto3.protoFilePackage pf - imports = Proto3.protoFileImports pf - defs = Proto3.protoFileTypes pf - options = Proto3.protoFileOptions pf - headerSec = - Optionals.given (Serialization.newlineSep [ - semi (Serialization.cst "syntax = \"proto3\""), - (semi (Serialization.spaceSep [ - Serialization.cst "package", - (Serialization.cst (Proto3.unPackageName pkg))]))]) - importsSec = - Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) - options1 = Lists.filter (\opt -> Logic.not (Equality.equal (Proto3.optionName opt) "_description")) options - optionsSec = fileOptionsToExpr options1 - defsSec = - Logic.ifElse (Lists.isEmpty defs) Nothing (Optionals.given (Serialization.doubleNewlineSep (Lists.map definitionToExpr defs))) - in (optDesc True options (Serialization.doubleNewlineSep (Optionals.givens [ - headerSec, - importsSec, - optionsSec, - defsSec]))) - --- | Convert a scalar type to an expression -scalarTypeToExpr :: Proto3.ScalarType -> Ast.Expr -scalarTypeToExpr sct = - Serialization.cst (case sct of - Proto3.ScalarTypeBool -> "bool" - Proto3.ScalarTypeBytes -> "bytes" - Proto3.ScalarTypeDouble -> "double" - Proto3.ScalarTypeFixed32 -> "fixed32" - Proto3.ScalarTypeFixed64 -> "fixed64" - Proto3.ScalarTypeFloat -> "float" - Proto3.ScalarTypeInt32 -> "int32" - Proto3.ScalarTypeInt64 -> "int64" - Proto3.ScalarTypeSfixed32 -> "sfixed32" - Proto3.ScalarTypeSfixed64 -> "sfixed64" - Proto3.ScalarTypeSint32 -> "sint32" - Proto3.ScalarTypeSint64 -> "sint64" - Proto3.ScalarTypeString -> "string" - Proto3.ScalarTypeUint32 -> "uint32" - Proto3.ScalarTypeUint64 -> "uint64") - --- | Append a semicolon to an expression -semi :: Ast.Expr -> Ast.Expr -semi e = - Serialization.noSep [ - e, - (Serialization.cst ";")] - --- | Convert a simple type to an expression -simpleTypeToExpr :: Proto3.SimpleType -> Ast.Expr -simpleTypeToExpr st = - case st of - Proto3.SimpleTypeReference v0 -> Serialization.cst (Proto3.unTypeName v0) - Proto3.SimpleTypeScalar v0 -> scalarTypeToExpr v0 - --- | Convert a value to an expression -valueToExpr :: Proto3.Value -> Ast.Expr -valueToExpr v = - Serialization.cst (case v of - Proto3.ValueBoolean v0 -> Logic.ifElse v0 "true" "false" - Proto3.ValueString v0 -> Literals.printString v0) diff --git a/src/main/haskell/Hydra/Protobuf/SourceContext.hs b/src/main/haskell/Hydra/Protobuf/SourceContext.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Protobuf/SourceContext.hs +++ /dev/null @@ -1,21 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Based on https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/source_context.proto - -module Hydra.Protobuf.SourceContext where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | `SourceContext` represents information about the source of a protobuf element, like the file in which it is defined. -data SourceContext = - SourceContext { - -- | The path-qualified name of the .proto file that contained the associated protobuf element. For example: `"google/protobuf/source_context.proto"`. - sourceContextFileName :: String} - deriving (Eq, Ord, Read, Show) - -_SourceContext = Core.Name "hydra.protobuf.sourceContext.SourceContext" - -_SourceContext_fileName = Core.Name "fileName" diff --git a/src/main/haskell/Hydra/Rust/Coder.hs b/src/main/haskell/Hydra/Rust/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Rust/Coder.hs +++ /dev/null @@ -1,536 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Rust code generator: converts Hydra type and term modules to Rust source code - -module Hydra.Rust.Coder 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.Environment as Environment -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Rust.Language as Language -import qualified Hydra.Rust.Serde as Serde -import qualified Hydra.Rust.Syntax as Syntax -import qualified Hydra.Scoping as Scoping -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variables as Variables -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | Encode a Hydra union field as a Rust enum variant -encodeEnumVariant :: t0 -> t1 -> Core.FieldType -> Either Errors.Error Syntax.EnumVariant -encodeEnumVariant cx g ft = - - let fname = Core.unName (Core.fieldTypeName ft) - ftyp = Core.fieldTypeType ft - dtyp = Strip.deannotateType ftyp - isUnit = - case dtyp of - Core.TypeUnit -> True - Core.TypeRecord v0 -> Lists.isEmpty v0 - _ -> False - in (Logic.ifElse isUnit (Right (Syntax.EnumVariant { - Syntax.enumVariantName = (Formatting.capitalize fname), - Syntax.enumVariantBody = Syntax.EnumVariantBodyUnit, - Syntax.enumVariantDoc = Nothing})) (case dtyp of - Core.TypeRecord v0 -> Eithers.bind (Eithers.mapList (encodeStructField cx g) v0) (\sfields -> Right (Syntax.EnumVariant { - Syntax.enumVariantName = (Formatting.capitalize fname), - Syntax.enumVariantBody = (Syntax.EnumVariantBodyStruct sfields), - Syntax.enumVariantDoc = Nothing})) - _ -> Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.EnumVariant { - Syntax.enumVariantName = (Formatting.capitalize fname), - Syntax.enumVariantBody = (Syntax.EnumVariantBodyTuple [ - sftyp]), - Syntax.enumVariantDoc = Nothing})))) - --- | Encode a Hydra literal value as a Rust expression -encodeLiteral :: Core.Literal -> Syntax.Expression -encodeLiteral lit = - case lit of - Core.LiteralBoolean v0 -> Syntax.ExpressionLiteral (Syntax.LiteralBool v0) - Core.LiteralString v0 -> Syntax.ExpressionLiteral (Syntax.LiteralString v0) - Core.LiteralFloat v0 -> case v0 of - Core.FloatValueFloat32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralFloat (Syntax.FloatLiteral { - Syntax.floatLiteralValue = (Literals.float32ToFloat64 v1), - Syntax.floatLiteralSuffix = (Just "f32")})) - Core.FloatValueFloat64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralFloat (Syntax.FloatLiteral { - Syntax.floatLiteralValue = v1, - Syntax.floatLiteralSuffix = Nothing})) - Core.LiteralInteger v0 -> case v0 of - Core.IntegerValueInt8 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.int8ToBigint v1), - Syntax.integerLiteralSuffix = (Just "i8")})) - Core.IntegerValueInt16 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.int16ToBigint v1), - Syntax.integerLiteralSuffix = (Just "i16")})) - Core.IntegerValueInt32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.int32ToBigint v1), - Syntax.integerLiteralSuffix = (Just "i32")})) - Core.IntegerValueInt64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.int64ToBigint v1), - Syntax.integerLiteralSuffix = (Just "i64")})) - Core.IntegerValueUint8 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.uint8ToBigint v1), - Syntax.integerLiteralSuffix = (Just "u8")})) - Core.IntegerValueUint16 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.uint16ToBigint v1), - Syntax.integerLiteralSuffix = (Just "u16")})) - Core.IntegerValueUint32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.uint32ToBigint v1), - Syntax.integerLiteralSuffix = (Just "u32")})) - Core.IntegerValueUint64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = (Literals.uint64ToBigint v1), - Syntax.integerLiteralSuffix = (Just "u64")})) - Core.IntegerValueBigint v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral { - Syntax.integerLiteralValue = v1, - Syntax.integerLiteralSuffix = Nothing})) - --- | Encode a Hydra literal type as a Rust type -encodeLiteralType :: Core.LiteralType -> Syntax.Type -encodeLiteralType lt = - case lt of - Core.LiteralTypeBinary -> rustApply1 "Vec" (rustPath "u8") - Core.LiteralTypeBoolean -> rustPath "bool" - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat32 -> rustPath "f32" - Core.FloatTypeFloat64 -> rustPath "f64" - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeBigint -> rustPathSegmented [ - "num", - "BigInt"] - Core.IntegerTypeInt8 -> rustPath "i8" - Core.IntegerTypeInt16 -> rustPath "i16" - Core.IntegerTypeInt32 -> rustPath "i32" - Core.IntegerTypeInt64 -> rustPath "i64" - Core.IntegerTypeUint8 -> rustPath "u8" - Core.IntegerTypeUint16 -> rustPath "u16" - Core.IntegerTypeUint32 -> rustPath "u32" - Core.IntegerTypeUint64 -> rustPath "u64" - Core.LiteralTypeString -> rustPath "String" - --- | Encode a Hydra record projection as a Rust expression. Takes an optional argument for applied projections. -encodeProjectionElim :: t0 -> t1 -> Core.Projection -> Maybe Core.Term -> Either Errors.Error Syntax.Expression -encodeProjectionElim cx g proj marg = - - let fname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.projectionFieldName proj)) - in (Optionals.match marg (Right (rustClosure [ - "v"] (Syntax.ExpressionFieldAccess (Syntax.FieldAccessExpr { - Syntax.fieldAccessExprObject = (rustExprPath "v"), - Syntax.fieldAccessExprField = fname})))) (\arg -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Syntax.ExpressionFieldAccess (Syntax.FieldAccessExpr { - Syntax.fieldAccessExprObject = sarg, - Syntax.fieldAccessExprField = fname}))))) - --- | Encode a Hydra record field as a Rust struct field -encodeStructField :: t0 -> t1 -> Core.FieldType -> Either Errors.Error Syntax.StructField -encodeStructField cx g ft = - - let fname = Core.unName (Core.fieldTypeName ft) - ftyp = Core.fieldTypeType ft - in (Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.StructField { - Syntax.structFieldName = (Formatting.convertCaseCamelToLowerSnake (Formatting.sanitizeWithUnderscores Language.rustReservedWords fname)), - Syntax.structFieldType = sftyp, - Syntax.structFieldPublic = True, - Syntax.structFieldDoc = Nothing}))) - --- | Encode a Hydra term as a Rust expression -encodeTerm :: t0 -> t1 -> Core.Term -> Either Errors.Error Syntax.Expression -encodeTerm cx g term = - case term of - Core.TermAnnotated v0 -> encodeTerm cx g (Core.annotatedTermBody v0) - Core.TermApplication v0 -> Eithers.bind (encodeTerm cx g (Core.applicationFunction v0)) (\fun -> Eithers.bind (encodeTerm cx g (Core.applicationArgument v0)) (\arg -> Right (rustCall fun [ - arg]))) - Core.TermEither v0 -> Eithers.either (\l -> Eithers.bind (encodeTerm cx g l) (\sl -> Right (rustCall (rustExprPath "Left") [ - sl]))) (\r -> Eithers.bind (encodeTerm cx g r) (\sr -> Right (rustCall (rustExprPath "Right") [ - sr]))) v0 - Core.TermLambda v0 -> - let param = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.lambdaParameter v0)) - in (Eithers.bind (encodeTerm cx g (Core.lambdaBody v0)) (\body -> Right (rustClosure [ - param] body))) - Core.TermProject v0 -> encodeProjectionElim cx g v0 Nothing - Core.TermCases v0 -> encodeUnionElim cx g v0 Nothing - Core.TermUnwrap v0 -> encodeUnwrapElim cx g v0 Nothing - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - body = Core.letBody v0 - in (Eithers.bind (Eithers.mapList (\b -> - let bname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.bindingName b)) - in (Eithers.bind (encodeTerm cx g (Core.bindingTerm b)) (\bval -> Right (rustLetStmt bname bval)))) bindings) (\stmts -> Eithers.bind (encodeTerm cx g body) (\bodyExpr -> Right (rustBlock stmts bodyExpr)))) - Core.TermList v0 -> Eithers.bind (Eithers.mapList (encodeTerm cx g) v0) (\sels -> Right (rustCall (rustExprPath "Vec::from") [ - Syntax.ExpressionArray (Syntax.ArrayExprElements sels)])) - Core.TermLiteral v0 -> Right (encodeLiteral v0) - Core.TermMap v0 -> Eithers.bind (Eithers.mapList (\entry -> Eithers.bind (encodeTerm cx g (Pairs.first entry)) (\k -> Eithers.bind (encodeTerm cx g (Pairs.second entry)) (\v -> Right (Syntax.ExpressionTuple [ - k, - v])))) (Maps.toList v0)) (\pairs -> Right (rustCall (rustExprPath "BTreeMap::from") [ - Syntax.ExpressionArray (Syntax.ArrayExprElements pairs)])) - Core.TermOptional v0 -> Optionals.match v0 (Right (rustExprPath "None")) (\val -> Eithers.bind (encodeTerm cx g val) (\sval -> Right (rustCall (rustExprPath "Some") [ - sval]))) - Core.TermPair v0 -> Eithers.bind (encodeTerm cx g (Pairs.first v0)) (\f -> Eithers.bind (encodeTerm cx g (Pairs.second v0)) (\s -> Right (Syntax.ExpressionTuple [ - f, - s]))) - Core.TermRecord v0 -> - let rname = Core.recordTypeName v0 - fields = Core.recordFields v0 - in (Eithers.bind (Eithers.mapList (\f -> - let fname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.fieldName f)) - in (Eithers.bind (encodeTerm cx g (Core.fieldTerm f)) (\fval -> Right (Syntax.FieldValue { - Syntax.fieldValueName = fname, - Syntax.fieldValueValue = (Just fval)})))) fields) (\sfields -> Right (Syntax.ExpressionStruct (Syntax.StructExpr { - Syntax.structExprPath = Syntax.ExprPath { - Syntax.exprPathGlobal = False, - Syntax.exprPathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = (Formatting.capitalize (Names.localNameOf rname)), - Syntax.pathSegmentArguments = Syntax.GenericArgumentsNone}]}, - Syntax.structExprFields = sfields, - Syntax.structExprRest = Nothing})))) - Core.TermSet v0 -> Eithers.bind (Eithers.mapList (encodeTerm cx g) (Sets.toList v0)) (\sels -> Right (rustCall (rustExprPath "BTreeSet::from") [ - Syntax.ExpressionArray (Syntax.ArrayExprElements sels)])) - Core.TermInject v0 -> - let tname = Formatting.capitalize (Names.localNameOf (Core.injectionTypeName v0)) - field = Core.injectionField v0 - fname = Formatting.capitalize (Core.unName (Core.fieldName field)) - fterm = Core.fieldTerm field - dterm = Strip.deannotateTerm fterm - isUnit = - case dterm of - Core.TermUnit -> True - Core.TermRecord v1 -> Lists.isEmpty (Core.recordFields v1) - _ -> False - in (Logic.ifElse isUnit (Right (rustExprPath (Strings.concat2 (Strings.concat2 tname "::") fname))) (Eithers.bind (encodeTerm cx g fterm) (\sval -> Right (rustCall (rustExprPath (Strings.concat2 (Strings.concat2 tname "::") fname)) [ - sval])))) - Core.TermUnit -> Right (Syntax.ExpressionTuple []) - Core.TermVariable v0 -> Right (rustExprPath (Formatting.convertCaseCamelToLowerSnake (Formatting.sanitizeWithUnderscores Language.rustReservedWords (Core.unName v0)))) - Core.TermWrap v0 -> - let tname = Formatting.capitalize (Names.localNameOf (Core.wrappedTermTypeName v0)) - in (Eithers.bind (encodeTerm cx g (Core.wrappedTermBody v0)) (\inner -> Right (rustCall (rustExprPath tname) [ - inner]))) - _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected term variant")) - --- | Encode a Hydra term definition as a Rust function item -encodeTermDefinition :: t0 -> t1 -> Packaging.TermDefinition -> Either Errors.Error Syntax.ItemWithComments -encodeTermDefinition cx g tdef = - - let name = Packaging.termDefinitionName tdef - term = Packaging.termDefinitionBody tdef - lname = Formatting.convertCaseCamelToLowerSnake (Names.localNameOf name) - typ = - Optionals.match (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature tdef)) (Core.TypeVariable (Core.Name "hydra.core.Unit")) Core.typeSchemeBody - in (Eithers.bind (encodeTerm cx g term) (\body -> Eithers.bind (encodeType cx g typ) (\retType -> Right (Syntax.ItemWithComments { - Syntax.itemWithCommentsDoc = Nothing, - Syntax.itemWithCommentsVisibility = Syntax.VisibilityPublic, - Syntax.itemWithCommentsItem = (Syntax.ItemFn (Syntax.FnDef { - Syntax.fnDefName = lname, - Syntax.fnDefGenerics = [], - Syntax.fnDefWhereClause = Nothing, - Syntax.fnDefParams = [], - Syntax.fnDefReturnType = (Just retType), - Syntax.fnDefBody = Syntax.Block { - Syntax.blockStatements = [], - Syntax.blockExpression = (Just body)}, - Syntax.fnDefPublic = True, - Syntax.fnDefAsync = False, - Syntax.fnDefConst = False, - Syntax.fnDefUnsafe = False, - Syntax.fnDefDoc = Nothing}))})))) - --- | Encode a Hydra type as a Rust syntax type -encodeType :: t0 -> t1 -> Core.Type -> Either Errors.Error Syntax.Type -encodeType cx g t = - - let typ = Strip.deannotateType t - in case typ of - Core.TypeAnnotated v0 -> encodeType cx g (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> encodeType cx g (Core.applicationTypeFunction v0) - Core.TypeUnit -> Right rustUnit - Core.TypeVoid -> Right rustUnit - Core.TypeLiteral v0 -> Right (encodeLiteralType v0) - Core.TypeList v0 -> Eithers.map (\enc -> rustApply1 "Vec" enc) (encodeType cx g v0) - Core.TypeSet v0 -> Eithers.map (\enc -> rustApply1 "BTreeSet" enc) (encodeType cx g v0) - Core.TypeMap v0 -> Eithers.bind (encodeType cx g (Core.mapTypeKeys v0)) (\kt -> Eithers.bind (encodeType cx g (Core.mapTypeValues v0)) (\vt -> Right (rustApply2 "BTreeMap" kt vt))) - Core.TypeOptional v0 -> Eithers.map (\enc -> rustApply1 "Option" enc) (encodeType cx g v0) - Core.TypeEither v0 -> Eithers.bind (encodeType cx g (Core.eitherTypeLeft v0)) (\lt -> Eithers.bind (encodeType cx g (Core.eitherTypeRight v0)) (\rt -> Right (rustApply2 "Either" lt rt))) - Core.TypePair v0 -> Eithers.bind (encodeType cx g (Core.pairTypeFirst v0)) (\ft -> Eithers.bind (encodeType cx g (Core.pairTypeSecond v0)) (\st -> Right (Syntax.TypeTuple [ - ft, - st]))) - Core.TypeFunction v0 -> Eithers.bind (encodeType cx g (Core.functionTypeDomain v0)) (\dom -> Eithers.bind (encodeType cx g (Core.functionTypeCodomain v0)) (\cod -> Right (rustApply1 "Box" (Syntax.TypeDynTrait [ - Syntax.TypeParamBoundTrait (Syntax.TypePath { - Syntax.typePathGlobal = False, - Syntax.typePathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = "Fn", - Syntax.pathSegmentArguments = (Syntax.GenericArgumentsParenthesized (Syntax.ParenthesizedArgs { - Syntax.parenthesizedArgsInputs = [ - dom], - Syntax.parenthesizedArgsOutput = (Just cod)}))}]})])))) - Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")) - Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type")) - Core.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrap type")) - Core.TypeVariable v0 -> Right (rustPath (Formatting.capitalize (Core.unName v0))) - Core.TypeForall v0 -> encodeType cx g (Core.forallTypeBody v0) - --- | Encode a Hydra type definition as a Rust item -encodeTypeDefinition :: t0 -> t1 -> Packaging.TypeDefinition -> Either Errors.Error Syntax.ItemWithComments -encodeTypeDefinition cx g tdef = - - let name = Packaging.typeDefinitionName tdef - typ = Core.typeSchemeBody (Packaging.typeDefinitionBody tdef) - lname = Formatting.capitalize (Names.localNameOf name) - freeVars = - Lists.filter (\v -> Equality.equal (Lists.length (Strings.splitOn "." (Core.unName v))) 1) (Sets.toList (Variables.freeVariablesInType typ)) - generics = - Lists.map (\v -> Syntax.GenericParam { - Syntax.genericParamName = (Formatting.capitalize (Core.unName v)), - Syntax.genericParamBounds = []}) freeVars - dtyp = Strip.deannotateType typ - in (Eithers.bind (case dtyp of - Core.TypeRecord v0 -> Eithers.bind (Eithers.mapList (encodeStructField cx g) v0) (\sfields -> Right (Syntax.ItemStruct (Syntax.StructDef { - Syntax.structDefName = lname, - Syntax.structDefGenerics = generics, - Syntax.structDefWhereClause = Nothing, - Syntax.structDefBody = (Syntax.StructBodyNamed sfields), - Syntax.structDefDerives = standardDerives, - Syntax.structDefPublic = True, - Syntax.structDefDoc = Nothing}))) - Core.TypeUnion v0 -> Eithers.bind (Eithers.mapList (encodeEnumVariant cx g) v0) (\variants -> Right (Syntax.ItemEnum (Syntax.EnumDef { - Syntax.enumDefName = lname, - Syntax.enumDefGenerics = generics, - Syntax.enumDefWhereClause = Nothing, - Syntax.enumDefVariants = variants, - Syntax.enumDefDerives = standardDerives, - Syntax.enumDefPublic = True, - Syntax.enumDefDoc = Nothing}))) - Core.TypeWrap v0 -> Eithers.bind (encodeType cx g v0) (\styp -> Right (Syntax.ItemStruct (Syntax.StructDef { - Syntax.structDefName = lname, - Syntax.structDefGenerics = generics, - Syntax.structDefWhereClause = Nothing, - Syntax.structDefBody = (Syntax.StructBodyTuple [ - Syntax.TupleField { - Syntax.tupleFieldType = styp, - Syntax.tupleFieldPublic = True}]), - Syntax.structDefDerives = standardDerives, - Syntax.structDefPublic = True, - Syntax.structDefDoc = Nothing}))) - _ -> Eithers.bind (encodeType cx g typ) (\styp -> Right (Syntax.ItemTypeAlias (Syntax.TypeAlias { - Syntax.typeAliasName = lname, - Syntax.typeAliasGenerics = generics, - Syntax.typeAliasType = styp, - Syntax.typeAliasPublic = True, - Syntax.typeAliasDoc = Nothing})))) (\item -> Right (Syntax.ItemWithComments { - Syntax.itemWithCommentsDoc = Nothing, - Syntax.itemWithCommentsVisibility = Syntax.VisibilityPublic, - Syntax.itemWithCommentsItem = item}))) - --- | Encode a Hydra case statement (union elimination) as a Rust expression. Takes an optional argument for applied case statements. -encodeUnionElim :: t0 -> t1 -> Core.CaseStatement -> Maybe Core.Term -> Either Errors.Error Syntax.Expression -encodeUnionElim cx g cs marg = - - let tname = Formatting.capitalize (Names.localNameOf (Core.caseStatementTypeName cs)) - caseFields = Core.caseStatementCases cs - defCase = Core.caseStatementDefault cs - in (Eithers.bind (Eithers.mapList (\cf -> - let cfname = Formatting.capitalize (Core.unName (Core.caseAlternativeName cf)) - cfterm = Core.caseAlternativeHandler cf - in (Eithers.bind (encodeTerm cx g (Core.TermApplication (Core.Application { - Core.applicationFunction = cfterm, - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))) (\armBody -> Right (Syntax.MatchArm { - Syntax.matchArmPattern = (Syntax.PatternTupleStruct (Syntax.TupleStructPattern { - Syntax.tupleStructPatternPath = Syntax.ExprPath { - Syntax.exprPathGlobal = False, - Syntax.exprPathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = (Strings.concat2 (Strings.concat2 tname "::") cfname), - Syntax.pathSegmentArguments = Syntax.GenericArgumentsNone}]}, - Syntax.tupleStructPatternElements = [ - Syntax.PatternIdentifier (Syntax.IdentifierPattern { - Syntax.identifierPatternName = "v", - Syntax.identifierPatternMutable = False, - Syntax.identifierPatternAtPattern = Nothing})]})), - Syntax.matchArmGuard = Nothing, - Syntax.matchArmBody = armBody})))) caseFields) (\arms -> Eithers.bind (Optionals.match defCase (Right arms) (\dt -> Eithers.bind (encodeTerm cx g (Core.TermApplication (Core.Application { - Core.applicationFunction = dt, - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))) (\defBody -> Right (Lists.concat2 arms [ - Syntax.MatchArm { - Syntax.matchArmPattern = Syntax.PatternWildcard, - Syntax.matchArmGuard = Nothing, - Syntax.matchArmBody = defBody}])))) (\allArms -> Optionals.match marg (Right (rustClosure [ - "v"] (Syntax.ExpressionMatch (Syntax.MatchExpr { - Syntax.matchExprScrutinee = (rustExprPath "v"), - Syntax.matchExprArms = allArms})))) (\arg -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Syntax.ExpressionMatch (Syntax.MatchExpr { - Syntax.matchExprScrutinee = sarg, - Syntax.matchExprArms = allArms}))))))) - --- | Encode a Hydra wrap elimination (unwrap) as a Rust expression. Takes an optional argument for applied unwraps. -encodeUnwrapElim :: t0 -> t1 -> Core.Name -> Maybe Core.Term -> Either Errors.Error Syntax.Expression -encodeUnwrapElim cx g name marg = - Optionals.match marg (Right (rustClosure [ - "v"] (Syntax.ExpressionTupleIndex (Syntax.TupleIndexExpr { - Syntax.tupleIndexExprTuple = (rustExprPath "v"), - Syntax.tupleIndexExprIndex = 0})))) (\arg -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Syntax.ExpressionTupleIndex (Syntax.TupleIndexExpr { - Syntax.tupleIndexExprTuple = sarg, - Syntax.tupleIndexExprIndex = 0})))) - --- | Convert a Hydra module to a map of file paths to Rust source code strings -moduleToRust :: Packaging.Module -> [Packaging.Definition] -> t0 -> t1 -> Either Errors.Error (M.Map String String) -moduleToRust mod defs cx g = - - let partitioned = Environment.partitionDefinitions defs - typeDefs = Pairs.first partitioned - termDefs = Pairs.second partitioned - in (Eithers.bind (Eithers.mapList (encodeTypeDefinition cx g) typeDefs) (\typeItems -> Eithers.bind (Eithers.mapList (encodeTermDefinition cx g) termDefs) (\termItems -> - let allItems = Lists.concat2 typeItems termItems - crate = Syntax.Crate { - Syntax.crateItems = allItems} - code = Serialization.printExpr (Serialization.parenthesize (Serde.crateToExpr crate)) - filePath = Names.moduleNameToFilePath Util.CaseConventionLowerSnake (File.FileExtension "rs") (Packaging.moduleName mod) - in (Right (Maps.singleton filePath code))))) - --- | Apply a type constructor to one type argument (e.g., Vec) -rustApply1 :: String -> Syntax.Type -> Syntax.Type -rustApply1 name arg = - Syntax.TypePath_ (Syntax.TypePath { - Syntax.typePathGlobal = False, - Syntax.typePathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = name, - Syntax.pathSegmentArguments = (Syntax.GenericArgumentsAngleBracketed (Syntax.AngleBracketedArgs { - Syntax.angleBracketedArgsArgs = [ - Syntax.GenericArgType arg]}))}]}) - --- | Apply a type constructor to two type arguments (e.g., BTreeMap) -rustApply2 :: String -> Syntax.Type -> Syntax.Type -> Syntax.Type -rustApply2 name arg1 arg2 = - Syntax.TypePath_ (Syntax.TypePath { - Syntax.typePathGlobal = False, - Syntax.typePathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = name, - Syntax.pathSegmentArguments = (Syntax.GenericArgumentsAngleBracketed (Syntax.AngleBracketedArgs { - Syntax.angleBracketedArgsArgs = [ - Syntax.GenericArgType arg1, - (Syntax.GenericArgType arg2)]}))}]}) - --- | Block expression with statements and trailing expression -rustBlock :: [Syntax.Statement] -> Syntax.Expression -> Syntax.Expression -rustBlock stmts expr = - Syntax.ExpressionBlock (Syntax.Block { - Syntax.blockStatements = stmts, - Syntax.blockExpression = (Just expr)}) - --- | Function call expression -rustCall :: Syntax.Expression -> [Syntax.Expression] -> Syntax.Expression -rustCall fun args = - Syntax.ExpressionCall (Syntax.CallExpr { - Syntax.callExprFunction = fun, - Syntax.callExprArgs = args}) - --- | Closure expression: |params| body -rustClosure :: [String] -> Syntax.Expression -> Syntax.Expression -rustClosure params body = - Syntax.ExpressionClosure (Syntax.ClosureExpr { - Syntax.closureExprMove = False, - Syntax.closureExprParams = (Lists.map (\p -> Syntax.ClosureParam { - Syntax.closureParamPattern = (Syntax.PatternIdentifier (Syntax.IdentifierPattern { - Syntax.identifierPatternName = p, - Syntax.identifierPatternMutable = False, - Syntax.identifierPatternAtPattern = Nothing})), - Syntax.closureParamType = Nothing}) params), - Syntax.closureExprReturnType = Nothing, - Syntax.closureExprBody = body}) - --- | Variable reference as a path expression -rustExprPath :: String -> Syntax.Expression -rustExprPath name = - Syntax.ExpressionPath (Syntax.ExprPath { - Syntax.exprPathGlobal = False, - Syntax.exprPathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = name, - Syntax.pathSegmentArguments = Syntax.GenericArgumentsNone}]}) - --- | Let statement: let name = expr; -rustLetStmt :: String -> Syntax.Expression -> Syntax.Statement -rustLetStmt name expr = - Syntax.StatementLet (Syntax.LetStatement { - Syntax.letStatementPattern = (Syntax.PatternIdentifier (Syntax.IdentifierPattern { - Syntax.identifierPatternName = name, - Syntax.identifierPatternMutable = False, - Syntax.identifierPatternAtPattern = Nothing})), - Syntax.letStatementMutable = False, - Syntax.letStatementType = Nothing, - Syntax.letStatementInit = (Just expr)}) - --- | Construct a simple Rust path type (e.g., "String" -> String) -rustPath :: String -> Syntax.Type -rustPath name = - Syntax.TypePath_ (Syntax.TypePath { - Syntax.typePathGlobal = False, - Syntax.typePathSegments = [ - Syntax.PathSegment { - Syntax.pathSegmentName = name, - Syntax.pathSegmentArguments = Syntax.GenericArgumentsNone}]}) - --- | Construct a Rust path type with multiple segments (e.g., ["num", "BigInt"] -> num::BigInt) -rustPathSegmented :: [String] -> Syntax.Type -rustPathSegmented segs = - Syntax.TypePath_ (Syntax.TypePath { - Syntax.typePathGlobal = False, - Syntax.typePathSegments = (Lists.map (\s -> Syntax.PathSegment { - Syntax.pathSegmentName = s, - Syntax.pathSegmentArguments = Syntax.GenericArgumentsNone}) segs)}) - --- | The Rust unit type () -rustUnit :: Syntax.Type -rustUnit = Syntax.TypeUnit - --- | The standard set of derive macros applied to generated structs and enums -standardDerives :: [String] -standardDerives = - [ - "Clone", - "Debug", - "PartialEq", - "Eq", - "PartialOrd", - "Ord"] diff --git a/src/main/haskell/Hydra/Rust/Language.hs b/src/main/haskell/Hydra/Rust/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Rust/Language.hs +++ /dev/null @@ -1,264 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints and reserved words for Rust - -module Hydra.Rust.Language 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.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.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, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Set as S - --- | Language constraints for Rust -rustLanguage :: Coders.Language -rustLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.rust"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "rs")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - integerTypes = - Sets.fromList [ - Core.IntegerTypeInt8, - Core.IntegerTypeInt16, - Core.IntegerTypeInt32, - Core.IntegerTypeInt64, - Core.IntegerTypeUint8, - Core.IntegerTypeUint16, - Core.IntegerTypeUint32, - Core.IntegerTypeUint64] - termVariants = - Sets.fromList [ - Variants.TermVariantAnnotated, - Variants.TermVariantApplication, - Variants.TermVariantEither, - Variants.TermVariantCases, - Variants.TermVariantLambda, - Variants.TermVariantProject, - Variants.TermVariantUnwrap, - Variants.TermVariantTypeApplication, - Variants.TermVariantTypeLambda, - Variants.TermVariantLet, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantPair, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantInject, - Variants.TermVariantUnit, - Variants.TermVariantVariable, - Variants.TermVariantWrap] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantFunction, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantUnit, - Variants.TypeVariantVariable, - Variants.TypeVariantVoid, - Variants.TypeVariantWrap] - typePredicate = \_ -> True - --- | A set of reserved words in Rust -rustReservedWords :: S.Set String -rustReservedWords = - Sets.fromList (Lists.concat [ - strictKeywords, - reservedKeywords, - weakKeywords, - primitiveTypes, - stdPreludeTypes, - hydraRustKeywords]) - where - strictKeywords = - [ - "as", - "async", - "await", - "break", - "const", - "continue", - "crate", - "dyn", - "else", - "enum", - "extern", - "false", - "fn", - "for", - "if", - "impl", - "in", - "let", - "loop", - "match", - "mod", - "move", - "mut", - "pub", - "ref", - "return", - "self", - "Self", - "static", - "struct", - "super", - "trait", - "true", - "type", - "unsafe", - "use", - "where", - "while"] - reservedKeywords = - [ - "abstract", - "become", - "box", - "do", - "final", - "macro", - "override", - "priv", - "try", - "typeof", - "unsized", - "virtual", - "yield"] - weakKeywords = - [ - "macro_rules", - "union", - "'static"] - primitiveTypes = - [ - "bool", - "char", - "str", - "u8", - "u16", - "u32", - "u64", - "u128", - "usize", - "i8", - "i16", - "i32", - "i64", - "i128", - "isize", - "f32", - "f64"] - stdPreludeTypes = - [ - "Option", - "Some", - "None", - "Result", - "Ok", - "Err", - "Box", - "String", - "Vec", - "Clone", - "Copy", - "Default", - "Drop", - "Eq", - "PartialEq", - "Ord", - "PartialOrd", - "Hash", - "Debug", - "Display", - "Iterator", - "IntoIterator", - "From", - "Into", - "AsRef", - "AsMut", - "Send", - "Sync", - "Sized", - "Unpin", - "Fn", - "FnMut", - "FnOnce"] - hydraRustKeywords = [ - "Node"] diff --git a/src/main/haskell/Hydra/Rust/Operators.hs b/src/main/haskell/Hydra/Rust/Operators.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Rust/Operators.hs +++ /dev/null @@ -1,271 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | AST operators for Rust serialization - -module Hydra.Rust.Operators where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Docs as Docs -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Add-assign operator (+=) -addAssignOp :: Ast.Op -addAssignOp = Serialization.op "+=" 1 Ast.AssociativityRight - --- | Addition operator (+) -addOp :: Ast.Op -addOp = Serialization.op "+" 10 Ast.AssociativityLeft - --- | Logical AND operator (&&) -andOp :: Ast.Op -andOp = Serialization.op "&&" 4 Ast.AssociativityLeft - --- | Function application operator (whitespace) -appOp :: Ast.Op -appOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsSpace}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityLeft} - --- | Return type arrow (->) -arrowOp :: Ast.Op -arrowOp = Serialization.op "->" 0 Ast.AssociativityRight - --- | Type cast operator (as) -asOp :: Ast.Op -asOp = Serialization.op "as" 12 Ast.AssociativityLeft - --- | Assignment operator (=) -assignOp :: Ast.Op -assignOp = Serialization.op "=" 1 Ast.AssociativityRight - --- | Bitwise and-assign operator (&=) -bitAndAssignOp :: Ast.Op -bitAndAssignOp = Serialization.op "&=" 1 Ast.AssociativityRight - --- | Bitwise AND operator (&) -bitAndOp :: Ast.Op -bitAndOp = Serialization.op "&" 8 Ast.AssociativityLeft - --- | Bitwise or-assign operator (|=) -bitOrAssignOp :: Ast.Op -bitOrAssignOp = Serialization.op "|=" 1 Ast.AssociativityRight - --- | Bitwise OR operator (|) -bitOrOp :: Ast.Op -bitOrOp = Serialization.op "|" 6 Ast.AssociativityLeft - --- | Bitwise xor-assign operator (^=) -bitXorAssignOp :: Ast.Op -bitXorAssignOp = Serialization.op "^=" 1 Ast.AssociativityRight - --- | Bitwise XOR operator (^) -bitXorOp :: Ast.Op -bitXorOp = Serialization.op "^" 7 Ast.AssociativityLeft - --- | Type annotation (::) for let statements -colonColonOp :: Ast.Op -colonColonOp = Serialization.op ":" 0 Ast.AssociativityNone - --- | Type ascription operator (:) -colonOp :: Ast.Op -colonOp = Serialization.op ":" 12 Ast.AssociativityLeft - --- | Dereference operator (*) -derefOp :: Ast.Op -derefOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "*"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 13), - Ast.opAssociativity = Ast.AssociativityNone} - --- | Div-assign operator (/=) -divAssignOp :: Ast.Op -divAssignOp = Serialization.op "/=" 1 Ast.AssociativityRight - --- | Division operator (/) -divOp :: Ast.Op -divOp = Serialization.op "/" 11 Ast.AssociativityLeft - --- | Path separator (::) -doubleColonOp :: Ast.Op -doubleColonOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "::"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 15), - Ast.opAssociativity = Ast.AssociativityLeft} - --- | Equality operator (==) -eqOp :: Ast.Op -eqOp = Serialization.op "==" 5 Ast.AssociativityNone - --- | Match arm arrow (=>) -fatArrowOp :: Ast.Op -fatArrowOp = Serialization.op "=>" 0 Ast.AssociativityNone - --- | Field access operator (.) -fieldOp :: Ast.Op -fieldOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "."), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 14), - Ast.opAssociativity = Ast.AssociativityLeft} - --- | Greater-than-or-equal operator (>=) -geOp :: Ast.Op -geOp = Serialization.op ">=" 5 Ast.AssociativityNone - --- | Greater-than operator (>) -gtOp :: Ast.Op -gtOp = Serialization.op ">" 5 Ast.AssociativityNone - --- | Less-than-or-equal operator (<=) -leOp :: Ast.Op -leOp = Serialization.op "<=" 5 Ast.AssociativityNone - --- | Less-than operator (<) -ltOp :: Ast.Op -ltOp = Serialization.op "<" 5 Ast.AssociativityNone - --- | Method call operator (.) -methodOp :: Ast.Op -methodOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "."), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 14), - Ast.opAssociativity = Ast.AssociativityLeft} - --- | Mul-assign operator (*=) -mulAssignOp :: Ast.Op -mulAssignOp = Serialization.op "*=" 1 Ast.AssociativityRight - --- | Multiplication operator (*) -mulOp :: Ast.Op -mulOp = Serialization.op "*" 11 Ast.AssociativityLeft - --- | Not-equal operator (!=) -neOp :: Ast.Op -neOp = Serialization.op "!=" 5 Ast.AssociativityNone - --- | Unary negation operator (-) -negOp :: Ast.Op -negOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "-"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 13), - Ast.opAssociativity = Ast.AssociativityNone} - --- | Unary logical not operator (!) -notOp :: Ast.Op -notOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "!"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 13), - Ast.opAssociativity = Ast.AssociativityNone} - --- | Logical OR operator (||) -orOp :: Ast.Op -orOp = Serialization.op "||" 3 Ast.AssociativityLeft - --- | Inclusive range operator (..=) -rangeInclusiveOp :: Ast.Op -rangeInclusiveOp = Serialization.op "..=" 2 Ast.AssociativityNone - --- | Range operator (..) -rangeOp :: Ast.Op -rangeOp = Serialization.op ".." 2 Ast.AssociativityNone - --- | Reference operator (&) -refOp :: Ast.Op -refOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "&"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 13), - Ast.opAssociativity = Ast.AssociativityNone} - --- | Rem-assign operator (%=) -remAssignOp :: Ast.Op -remAssignOp = Serialization.op "%=" 1 Ast.AssociativityRight - --- | Remainder operator (%) -remOp :: Ast.Op -remOp = Serialization.op "%" 11 Ast.AssociativityLeft - --- | Shift-left assign operator (<<=) -shlAssignOp :: Ast.Op -shlAssignOp = Serialization.op "<<=" 1 Ast.AssociativityRight - --- | Shift-left operator (<<) -shlOp :: Ast.Op -shlOp = Serialization.op "<<" 9 Ast.AssociativityLeft - --- | Shift-right assign operator (>>=) -shrAssignOp :: Ast.Op -shrAssignOp = Serialization.op ">>=" 1 Ast.AssociativityRight - --- | Shift-right operator (>>) -shrOp :: Ast.Op -shrOp = Serialization.op ">>" 9 Ast.AssociativityLeft - --- | Sub-assign operator (-=) -subAssignOp :: Ast.Op -subAssignOp = Serialization.op "-=" 1 Ast.AssociativityRight - --- | Subtraction operator (-) -subOp :: Ast.Op -subOp = Serialization.op "-" 10 Ast.AssociativityLeft diff --git a/src/main/haskell/Hydra/Rust/Serde.hs b/src/main/haskell/Hydra/Rust/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Rust/Serde.hs +++ /dev/null @@ -1,1405 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Rust serializer: converts Rust AST to concrete syntax - -module Hydra.Rust.Serde where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Core as Core -import qualified Hydra.Docs as Docs -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as ErrorCore -import qualified Hydra.Error.File as ErrorFile -import qualified Hydra.Error.Packaging as ErrorPackaging -import qualified Hydra.Error.System as ErrorSystem -import qualified Hydra.Errors as Errors -import qualified Hydra.File as File -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Rust.Operators as Operators -import qualified Hydra.Rust.Syntax as Syntax -import qualified Hydra.Serialization as Serialization -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Serialize an array expression -arrayExprToExpr :: Syntax.ArrayExpr -> Ast.Expr -arrayExprToExpr a = - case a of - Syntax.ArrayExprElements v0 -> Serialization.bracketList Serialization.halfBlockStyle (Lists.map expressionToExpr v0) - Syntax.ArrayExprRepeat v0 -> - let elem = Syntax.arrayRepeatElement v0 - len = Syntax.arrayRepeatLength v0 - in (Serialization.cst (Strings.concat [ - "[", - (Serialization.printExpr (expressionToExpr elem)), - "; ", - (Serialization.printExpr (expressionToExpr len)), - "]"])) - --- | Serialize an assignment expression -assignExprToExpr :: Syntax.AssignExpr -> Ast.Expr -assignExprToExpr a = - - let target = Syntax.assignExprTarget a - val = Syntax.assignExprValue a - in (Serialization.spaceSep [ - expressionToExpr target, - (Serialization.cst "="), - (expressionToExpr val)]) - --- | Serialize an attribute -attributeToExpr :: Syntax.Attribute -> Ast.Expr -attributeToExpr attr = - - let inner = Syntax.attributeInner attr - path = Syntax.attributePath attr - tokens = Syntax.attributeTokens attr - prefix = Logic.ifElse inner "#![" "#[" - pathStr = Strings.join "::" path - tokensPart = - Optionals.match tokens "" (\t -> Strings.concat [ - "(", - t, - ")"]) - in (Serialization.cst (Strings.concat [ - prefix, - pathStr, - tokensPart, - "]"])) - --- | Serialize a binary expression -binaryExprToExpr :: Syntax.BinaryExpr -> Ast.Expr -binaryExprToExpr b = - - let left = Syntax.binaryExprLeft b - op = Syntax.binaryExprOp b - right = Syntax.binaryExprRight b - in (Serialization.spaceSep [ - expressionToExpr left, - (binaryOpToExpr op), - (expressionToExpr right)]) - --- | Serialize a binary operator -binaryOpToExpr :: Syntax.BinaryOp -> Ast.Expr -binaryOpToExpr op = - Serialization.cst (case op of - Syntax.BinaryOpAdd -> "+" - Syntax.BinaryOpSub -> "-" - Syntax.BinaryOpMul -> "*" - Syntax.BinaryOpDiv -> "/" - Syntax.BinaryOpRem -> "%" - Syntax.BinaryOpAnd -> "&&" - Syntax.BinaryOpOr -> "||" - Syntax.BinaryOpBitAnd -> "&" - Syntax.BinaryOpBitOr -> "|" - Syntax.BinaryOpBitXor -> "^" - Syntax.BinaryOpShl -> "<<" - Syntax.BinaryOpShr -> ">>" - Syntax.BinaryOpEq -> "==" - Syntax.BinaryOpNe -> "!=" - Syntax.BinaryOpLt -> "<" - Syntax.BinaryOpLe -> "<=" - Syntax.BinaryOpGt -> ">" - Syntax.BinaryOpGe -> ">=") - --- | Serialize a block -blockToExpr :: Syntax.Block -> Ast.Expr -blockToExpr b = - - let stmts = Syntax.blockStatements b - expr = Syntax.blockExpression b - stmtExprs = Lists.map statementToExpr stmts - exprPart = Optionals.match expr [] (\e -> [ - expressionToExpr e]) - allParts = Lists.concat2 stmtExprs exprPart - in (Serialization.curlyBracesList Nothing Serialization.halfBlockStyle allParts) - --- | Serialize a function call expression -callExprToExpr :: Syntax.CallExpr -> Ast.Expr -callExprToExpr c = - - let func = Syntax.callExprFunction c - args = Syntax.callExprArgs c - in (Serialization.spaceSep [ - expressionToExpr func, - (Serialization.parenListAdaptive (Lists.map expressionToExpr args))]) - --- | Serialize a cast expression -castExprToExpr :: Syntax.CastExpr -> Ast.Expr -castExprToExpr c = - - let expr = Syntax.castExprExpr c - typ = Syntax.castExprType c - in (Serialization.spaceSep [ - expressionToExpr expr, - (Serialization.cst "as"), - (typeToExpr typ)]) - --- | Serialize a closure expression -closureExprToExpr :: Syntax.ClosureExpr -> Ast.Expr -closureExprToExpr c = - - let move = Syntax.closureExprMove c - params = Syntax.closureExprParams c - retType = Syntax.closureExprReturnType c - body = Syntax.closureExprBody c - moveKw = Logic.ifElse move (Just (Serialization.cst "move")) Nothing - paramsStr = - Strings.concat [ - "|", - (Strings.join ", " (Lists.map closureParamToStr params)), - "|"] - retPart = - Optionals.match retType Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst "->", - (typeToExpr t)])) - in (Serialization.spaceSep (Optionals.givens [ - moveKw, - (Just (Serialization.cst paramsStr)), - retPart, - (Just (expressionToExpr body))])) - --- | Serialize a closure parameter to string -closureParamToStr :: Syntax.ClosureParam -> String -closureParamToStr cp = - - let pat = Syntax.closureParamPattern cp - typ = Syntax.closureParamType cp - patStr = Serialization.printExpr (patternToExpr pat) - in (Optionals.match typ patStr (\t -> Strings.concat [ - patStr, - ": ", - (Serialization.printExpr (typeToExpr t))])) - --- | Serialize a compound assignment expression -compoundAssignExprToExpr :: Syntax.CompoundAssignExpr -> Ast.Expr -compoundAssignExprToExpr c = - - let target = Syntax.compoundAssignExprTarget c - op = Syntax.compoundAssignExprOp c - val = Syntax.compoundAssignExprValue c - opStr = - case op of - Syntax.CompoundAssignOpAddAssign -> "+=" - Syntax.CompoundAssignOpSubAssign -> "-=" - Syntax.CompoundAssignOpMulAssign -> "*=" - Syntax.CompoundAssignOpDivAssign -> "/=" - Syntax.CompoundAssignOpRemAssign -> "%=" - Syntax.CompoundAssignOpBitAndAssign -> "&=" - Syntax.CompoundAssignOpBitOrAssign -> "|=" - Syntax.CompoundAssignOpBitXorAssign -> "^=" - Syntax.CompoundAssignOpShlAssign -> "<<=" - Syntax.CompoundAssignOpShrAssign -> ">>=" - in (Serialization.spaceSep [ - expressionToExpr target, - (Serialization.cst opStr), - (expressionToExpr val)]) - --- | Serialize a const definition -constDefToExpr :: Syntax.ConstDef -> Ast.Expr -constDefToExpr c = - - let name = Syntax.constDefName c - typ = Syntax.constDefType c - val = Syntax.constDefValue c - in (Serialization.spaceSep [ - Serialization.cst "const", - (Serialization.cst (Strings.concat2 name ":")), - (typeToExpr typ), - (Serialization.cst "="), - (expressionToExpr val), - (Serialization.cst ";")]) - --- | Serialize a Rust crate to an AST expression -crateToExpr :: Syntax.Crate -> Ast.Expr -crateToExpr crate = Serialization.doubleNewlineSep (Lists.map itemWithCommentsToExpr (Syntax.crateItems crate)) - --- | Serialize derive macros to an attribute expression -derivesToExpr :: [String] -> Maybe Ast.Expr -derivesToExpr derives = - Logic.ifElse (Lists.isEmpty derives) Nothing (Just (Serialization.cst (Strings.concat [ - "#[derive(", - (Strings.join ", " derives), - ")]"]))) - --- | Serialize an enum definition -enumDefToExpr :: Syntax.EnumDef -> Ast.Expr -enumDefToExpr e = - - let name = Syntax.enumDefName e - generics = Syntax.enumDefGenerics e - whereC = Syntax.enumDefWhereClause e - variants = Syntax.enumDefVariants e - derives = Syntax.enumDefDerives e - docC = Syntax.enumDefDoc e - derivesAttr = derivesToExpr derives - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - header = - Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "enum"), - (Just (Serialization.cst name)), - (genericParamsToExpr generics)]) - wherePart = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - body = Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map enumVariantToExpr variants) - in (Serialization.newlineSep (Lists.concat [ - docPart, - (Optionals.match derivesAttr [] (\d -> [ - d])), - [ - Serialization.spaceSep (Optionals.givens [ - Just header, - wherePart, - (Just body)])]])) - --- | Serialize an enum variant body -enumVariantBodyToExpr :: Syntax.EnumVariantBody -> Ast.Expr -enumVariantBodyToExpr body = - case body of - Syntax.EnumVariantBodyUnit -> Serialization.cst "" - Syntax.EnumVariantBodyTuple v0 -> Serialization.parenListAdaptive (Lists.map typeToExpr v0) - Syntax.EnumVariantBodyStruct v0 -> Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map structFieldToExpr v0) - --- | Serialize an enum variant -enumVariantToExpr :: Syntax.EnumVariant -> Ast.Expr -enumVariantToExpr v = - - let name = Syntax.enumVariantName v - body = Syntax.enumVariantBody v - docC = Syntax.enumVariantDoc v - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep [ - Serialization.cst name, - (enumVariantBodyToExpr body)]]])) - --- | Serialize an expression path -exprPathToExpr :: Syntax.ExprPath -> Ast.Expr -exprPathToExpr ep = - - let global = Syntax.exprPathGlobal ep - segs = Syntax.exprPathSegments ep - prefix = Logic.ifElse global "::" "" - segStrs = Lists.map (\s -> Serialization.printExpr (pathSegmentToExpr s)) segs - in (Serialization.cst (Strings.concat2 prefix (Strings.join "::" segStrs))) - --- | Serialize a Rust expression -expressionToExpr :: Syntax.Expression -> Ast.Expr -expressionToExpr expr = - case expr of - Syntax.ExpressionLiteral v0 -> literalToExpr v0 - Syntax.ExpressionPath v0 -> exprPathToExpr v0 - Syntax.ExpressionBlock v0 -> blockToExpr v0 - Syntax.ExpressionCall v0 -> callExprToExpr v0 - Syntax.ExpressionMethodCall v0 -> methodCallExprToExpr v0 - Syntax.ExpressionFieldAccess v0 -> fieldAccessExprToExpr v0 - Syntax.ExpressionTupleIndex v0 -> tupleIndexExprToExpr v0 - Syntax.ExpressionClosure v0 -> closureExprToExpr v0 - Syntax.ExpressionIf v0 -> ifExprToExpr v0 - Syntax.ExpressionMatch v0 -> matchExprToExpr v0 - Syntax.ExpressionLoop v0 -> loopExprToExpr v0 - Syntax.ExpressionWhile v0 -> whileExprToExpr v0 - Syntax.ExpressionFor v0 -> forExprToExpr v0 - Syntax.ExpressionBinary v0 -> binaryExprToExpr v0 - Syntax.ExpressionUnary v0 -> unaryExprToExpr v0 - Syntax.ExpressionReference v0 -> refExprToExpr v0 - Syntax.ExpressionDereference v0 -> Serialization.prefix "*" (expressionToExpr v0) - Syntax.ExpressionStruct v0 -> structExprToExpr v0 - Syntax.ExpressionTuple v0 -> Serialization.parenListAdaptive (Lists.map expressionToExpr v0) - Syntax.ExpressionArray v0 -> arrayExprToExpr v0 - Syntax.ExpressionIndex v0 -> indexExprToExpr v0 - Syntax.ExpressionRange v0 -> rangeExprToExpr v0 - Syntax.ExpressionReturn v0 -> Optionals.match v0 (Serialization.cst "return") (\e -> Serialization.spaceSep [ - Serialization.cst "return", - (expressionToExpr e)]) - Syntax.ExpressionBreak v0 -> Optionals.match v0 (Serialization.cst "break") (\e -> Serialization.spaceSep [ - Serialization.cst "break", - (expressionToExpr e)]) - Syntax.ExpressionContinue -> Serialization.cst "continue" - Syntax.ExpressionTry v0 -> Serialization.cst (Strings.concat2 (Serialization.printExpr (expressionToExpr v0)) "?") - Syntax.ExpressionCast v0 -> castExprToExpr v0 - Syntax.ExpressionTypeAscription v0 -> typeAscriptionExprToExpr v0 - Syntax.ExpressionAwait v0 -> Serialization.cst (Strings.concat2 (Serialization.printExpr (expressionToExpr v0)) ".await") - Syntax.ExpressionAssign v0 -> assignExprToExpr v0 - Syntax.ExpressionCompoundAssign v0 -> compoundAssignExprToExpr v0 - Syntax.ExpressionMacro v0 -> macroInvocationToExpr v0 - Syntax.ExpressionParen v0 -> Serialization.parenthesize (expressionToExpr v0) - --- | Serialize a field access expression -fieldAccessExprToExpr :: Syntax.FieldAccessExpr -> Ast.Expr -fieldAccessExprToExpr f = - - let obj = Syntax.fieldAccessExprObject f - field = Syntax.fieldAccessExprField f - in (Serialization.cst (Strings.concat [ - Serialization.printExpr (expressionToExpr obj), - ".", - field])) - --- | Serialize a field pattern -fieldPatternToExpr :: Syntax.FieldPattern -> Ast.Expr -fieldPatternToExpr fp = - - let name = Syntax.fieldPatternName fp - pat = Syntax.fieldPatternPattern fp - in (Optionals.match pat (Serialization.cst name) (\p -> Serialization.spaceSep [ - Serialization.cst (Strings.concat2 name ":"), - (patternToExpr p)])) - --- | Serialize a field-value pair -fieldValueToExpr :: Syntax.FieldValue -> Ast.Expr -fieldValueToExpr fv = - - let name = Syntax.fieldValueName fv - val = Syntax.fieldValueValue fv - in (Optionals.match val (Serialization.cst name) (\v -> Serialization.spaceSep [ - Serialization.cst (Strings.concat2 name ":"), - (expressionToExpr v)])) - --- | Serialize a float literal -floatLiteralToExpr :: Syntax.FloatLiteral -> Ast.Expr -floatLiteralToExpr fl = - - let val = Syntax.floatLiteralValue fl - suf = Syntax.floatLiteralSuffix fl - valStr = Literals.printFloat64 val - sufStr = Optionals.match suf "" (\s -> s) - in (Serialization.cst (Strings.concat2 valStr sufStr)) - --- | Serialize a function definition -fnDefToExpr :: Syntax.FnDef -> Ast.Expr -fnDefToExpr f = - - let name = Syntax.fnDefName f - generics = Syntax.fnDefGenerics f - whereC = Syntax.fnDefWhereClause f - params = Syntax.fnDefParams f - retType = Syntax.fnDefReturnType f - body = Syntax.fnDefBody f - isAsync = Syntax.fnDefAsync f - isConst = Syntax.fnDefConst f - isUnsafe = Syntax.fnDefUnsafe f - docC = Syntax.fnDefDoc f - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - asyncKw = Logic.ifElse isAsync (Just (Serialization.cst "async")) Nothing - constKw = Logic.ifElse isConst (Just (Serialization.cst "const")) Nothing - unsafeKw = Logic.ifElse isUnsafe (Just (Serialization.cst "unsafe")) Nothing - fnKw = Serialization.cst "fn" - nameExpr = Serialization.cst name - genericsExpr = genericParamsToExpr generics - paramsExpr = Serialization.parenListAdaptive (Lists.map fnParamToExpr params) - retTypeExpr = - Optionals.match retType Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst "->", - (typeToExpr t)])) - whereExpr = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - header = - Serialization.spaceSep (Optionals.givens [ - asyncKw, - constKw, - unsafeKw, - (Just fnKw), - (Just nameExpr), - genericsExpr, - (Just paramsExpr), - retTypeExpr, - whereExpr]) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep [ - header, - (blockToExpr body)]]])) - --- | Serialize a function parameter -fnParamToExpr :: Syntax.FnParam -> Ast.Expr -fnParamToExpr param = - - let pat = Syntax.fnParamPattern param - typ = Syntax.fnParamType param - in (Serialization.spaceSep [ - Serialization.cst (Strings.concat2 (Serialization.printExpr (patternToExpr pat)) ":"), - (typeToExpr typ)]) - --- | Serialize a for expression -forExprToExpr :: Syntax.ForExpr -> Ast.Expr -forExprToExpr f = - - let label = Syntax.forExprLabel f - pat = Syntax.forExprPattern f - iter = Syntax.forExprIter f - body = Syntax.forExprBody f - labelPart = - Optionals.match label Nothing (\lbl -> Just (Serialization.cst (Strings.concat2 "'" (Strings.concat2 lbl ":")))) - in (Serialization.spaceSep (Optionals.givens [ - labelPart, - (Just (Serialization.cst "for")), - (Just (patternToExpr pat)), - (Just (Serialization.cst "in")), - (Just (expressionToExpr iter)), - (Just (blockToExpr body))])) - --- | Serialize a generic argument -genericArgToExpr :: Syntax.GenericArg -> Ast.Expr -genericArgToExpr arg = - case arg of - Syntax.GenericArgType v0 -> typeToExpr v0 - Syntax.GenericArgLifetime v0 -> Serialization.cst (Strings.concat2 "'" (Syntax.lifetimeName v0)) - Syntax.GenericArgConst v0 -> expressionToExpr v0 - Syntax.GenericArgBinding v0 -> - let name = Syntax.typeBindingName v0 - typ = Syntax.typeBindingType v0 - in (Serialization.spaceSep [ - Serialization.cst name, - (Serialization.cst "="), - (typeToExpr typ)]) - --- | Serialize generic arguments -genericArgumentsToExpr :: Syntax.GenericArguments -> Maybe Ast.Expr -genericArgumentsToExpr args = - case args of - Syntax.GenericArgumentsNone -> Nothing - Syntax.GenericArgumentsAngleBracketed v0 -> - let args = Syntax.angleBracketedArgsArgs v0 - in (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map genericArgToExpr args))) - Syntax.GenericArgumentsParenthesized v0 -> - let inputs = Syntax.parenthesizedArgsInputs v0 - output = Syntax.parenthesizedArgsOutput v0 - inputPart = Serialization.parenListAdaptive (Lists.map typeToExpr inputs) - outputPart = - Optionals.match output Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst "->", - (typeToExpr t)])) - in (Just (Serialization.spaceSep (Optionals.givens [ - Just inputPart, - outputPart]))) - --- | Serialize a generic parameter -genericParamToExpr :: Syntax.GenericParam -> Ast.Expr -genericParamToExpr gp = - - let name = Syntax.genericParamName gp - bounds = Syntax.genericParamBounds gp - in (Logic.ifElse (Lists.isEmpty bounds) (Serialization.cst name) (Serialization.spaceSep [ - Serialization.cst (Strings.concat2 name ":"), - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) bounds)))])) - --- | Serialize a list of generic parameters -genericParamsToExpr :: [Syntax.GenericParam] -> Maybe Ast.Expr -genericParamsToExpr gps = - Logic.ifElse (Lists.isEmpty gps) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map genericParamToExpr gps))) - --- | Serialize an identifier pattern -identifierPatternToExpr :: Syntax.IdentifierPattern -> Ast.Expr -identifierPatternToExpr ip = - - let name = Syntax.identifierPatternName ip - mut = Syntax.identifierPatternMutable ip - atPat = Syntax.identifierPatternAtPattern ip - mutKw = Logic.ifElse mut (Just (Serialization.cst "mut")) Nothing - atPart = - Optionals.match atPat Nothing (\p -> Just (Serialization.spaceSep [ - Serialization.cst "@", - (patternToExpr p)])) - in (Serialization.spaceSep (Optionals.givens [ - mutKw, - (Just (Serialization.cst name)), - atPart])) - --- | Serialize an if expression -ifExprToExpr :: Syntax.IfExpr -> Ast.Expr -ifExprToExpr i = - - let cond = Syntax.ifExprCondition i - thenB = Syntax.ifExprThenBlock i - elseB = Syntax.ifExprElseBranch i - condExpr = - case cond of - Syntax.IfConditionBool v0 -> expressionToExpr v0 - Syntax.IfConditionLet v0 -> - let pat = Syntax.letConditionPattern v0 - expr = Syntax.letConditionExpr v0 - in (Serialization.spaceSep [ - Serialization.cst "let", - (patternToExpr pat), - (Serialization.cst "="), - (expressionToExpr expr)]) - elsePart = - Optionals.match elseB Nothing (\e -> Just (Serialization.spaceSep [ - Serialization.cst "else", - (expressionToExpr e)])) - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "if"), - (Just condExpr), - (Just (blockToExpr thenB)), - elsePart])) - --- | Serialize an impl block -implBlockToExpr :: Syntax.ImplBlock -> Ast.Expr -implBlockToExpr i = - - let generics = Syntax.implBlockGenerics i - whereC = Syntax.implBlockWhereClause i - trait = Syntax.implBlockTrait i - selfType = Syntax.implBlockSelfType i - items = Syntax.implBlockItems i - genericsExpr = genericParamsToExpr generics - traitPart = - Optionals.match trait Nothing (\t -> Just (Serialization.spaceSep [ - typePathToExpr t, - (Serialization.cst "for")])) - wherePart = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - header = - Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "impl"), - genericsExpr, - traitPart, - (Just (typeToExpr selfType)), - wherePart]) - body = Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map implItemToExpr items) - in (Serialization.spaceSep [ - header, - body]) - --- | Serialize an impl item -implItemToExpr :: Syntax.ImplItem -> Ast.Expr -implItemToExpr item = - case item of - Syntax.ImplItemMethod v0 -> implMethodToExpr v0 - Syntax.ImplItemType v0 -> typeAliasToExpr v0 - Syntax.ImplItemConst v0 -> constDefToExpr v0 - --- | Serialize an impl method -implMethodToExpr :: Syntax.ImplMethod -> Ast.Expr -implMethodToExpr m = - - let name = Syntax.implMethodName m - generics = Syntax.implMethodGenerics m - whereC = Syntax.implMethodWhereClause m - params = Syntax.implMethodParams m - retType = Syntax.implMethodReturnType m - body = Syntax.implMethodBody m - pub = Syntax.implMethodPublic m - docC = Syntax.implMethodDoc m - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - pubKw = Logic.ifElse pub (Just (Serialization.cst "pub")) Nothing - genericsExpr = genericParamsToExpr generics - paramsExpr = Serialization.parenListAdaptive (Lists.map methodParamToExpr params) - retTypeExpr = - Optionals.match retType Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst "->", - (typeToExpr t)])) - whereExpr = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - header = - Serialization.spaceSep (Optionals.givens [ - pubKw, - (Just (Serialization.cst "fn")), - (Just (Serialization.cst name)), - genericsExpr, - (Just paramsExpr), - retTypeExpr, - whereExpr]) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep [ - header, - (blockToExpr body)]]])) - --- | Serialize an index expression -indexExprToExpr :: Syntax.IndexExpr -> Ast.Expr -indexExprToExpr i = - - let obj = Syntax.indexExprObject i - idx = Syntax.indexExprIndex i - in (Serialization.cst (Strings.concat [ - Serialization.printExpr (expressionToExpr obj), - "[", - (Serialization.printExpr (expressionToExpr idx)), - "]"])) - --- | Serialize an integer literal -integerLiteralToExpr :: Syntax.IntegerLiteral -> Ast.Expr -integerLiteralToExpr il = - - let val = Syntax.integerLiteralValue il - suf = Syntax.integerLiteralSuffix il - valStr = Literals.printBigint val - sufStr = Optionals.match suf "" (\s -> s) - in (Serialization.cst (Strings.concat2 valStr sufStr)) - --- | Serialize a Rust item to an AST expression -itemToExpr :: Syntax.Item -> Ast.Expr -itemToExpr item = - case item of - Syntax.ItemUse v0 -> useDeclarationToExpr v0 - Syntax.ItemStruct v0 -> structDefToExpr v0 - Syntax.ItemEnum v0 -> enumDefToExpr v0 - Syntax.ItemFn v0 -> fnDefToExpr v0 - Syntax.ItemTypeAlias v0 -> typeAliasToExpr v0 - Syntax.ItemImpl v0 -> implBlockToExpr v0 - Syntax.ItemTrait v0 -> traitDefToExpr v0 - Syntax.ItemMod v0 -> modDefToExpr v0 - Syntax.ItemConst v0 -> constDefToExpr v0 - Syntax.ItemStatic v0 -> staticDefToExpr v0 - Syntax.ItemMacro v0 -> macroInvocationToExpr v0 - --- | Serialize an item with optional doc comments and visibility -itemWithCommentsToExpr :: Syntax.ItemWithComments -> Ast.Expr -itemWithCommentsToExpr iwc = - - let doc = Syntax.itemWithCommentsDoc iwc - vis = Syntax.itemWithCommentsVisibility iwc - item = Syntax.itemWithCommentsItem iwc - docPart = Optionals.match doc [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - visPart = visibilityToExpr vis - itemPart = itemToExpr item - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep (Optionals.givens [ - visPart, - (Just itemPart)])]])) - --- | Serialize a let statement -letStatementToExpr :: Syntax.LetStatement -> Ast.Expr -letStatementToExpr l = - - let pat = Syntax.letStatementPattern l - mut = Syntax.letStatementMutable l - typ = Syntax.letStatementType l - init = Syntax.letStatementInit l - mutKw = Logic.ifElse mut (Just (Serialization.cst "mut")) Nothing - typPart = - Optionals.match typ Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst ":", - (typeToExpr t)])) - initPart = - Optionals.match init Nothing (\e -> Just (Serialization.spaceSep [ - Serialization.cst "=", - (expressionToExpr e)])) - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "let"), - mutKw, - (Just (patternToExpr pat)), - typPart, - initPart, - (Just (Serialization.cst ";"))])) - --- | Serialize a literal -literalToExpr :: Syntax.Literal -> Ast.Expr -literalToExpr lit = - case lit of - Syntax.LiteralInteger v0 -> integerLiteralToExpr v0 - Syntax.LiteralFloat v0 -> floatLiteralToExpr v0 - Syntax.LiteralString v0 -> Serialization.cst (Literals.printString v0) - Syntax.LiteralRawString v0 -> Serialization.cst (Strings.concat [ - "r\"", - v0, - "\""]) - Syntax.LiteralByteString _ -> Serialization.cst "b\"...\"" - Syntax.LiteralChar v0 -> Serialization.cst (Strings.concat [ - "'", - (Literals.printUint32 v0), - "'"]) - Syntax.LiteralByte v0 -> Serialization.cst (Strings.concat [ - "b'", - (Literals.printUint8 v0), - "'"]) - Syntax.LiteralBool v0 -> Serialization.cst (Logic.ifElse v0 "true" "false") - --- | Serialize a loop expression -loopExprToExpr :: Syntax.LoopExpr -> Ast.Expr -loopExprToExpr l = - - let label = Syntax.loopExprLabel l - body = Syntax.loopExprBody l - labelPart = - Optionals.match label Nothing (\lbl -> Just (Serialization.cst (Strings.concat2 "'" (Strings.concat2 lbl ":")))) - in (Serialization.spaceSep (Optionals.givens [ - labelPart, - (Just (Serialization.cst "loop")), - (Just (blockToExpr body))])) - --- | Serialize a macro invocation -macroInvocationToExpr :: Syntax.MacroInvocation -> Ast.Expr -macroInvocationToExpr m = - - let path = Syntax.macroInvocationPath m - delim = Syntax.macroInvocationDelimiter m - tokens = Syntax.macroInvocationTokens m - pathStr = Strings.join "::" path - open = - case delim of - Syntax.MacroDelimiterParen -> "(" - Syntax.MacroDelimiterBracket -> "[" - Syntax.MacroDelimiterBrace -> "{" - close = - case delim of - Syntax.MacroDelimiterParen -> ")" - Syntax.MacroDelimiterBracket -> "]" - Syntax.MacroDelimiterBrace -> "}" - in (Serialization.cst (Strings.concat [ - pathStr, - "!", - open, - tokens, - close])) - --- | Serialize a match arm -matchArmToExpr :: Syntax.MatchArm -> Ast.Expr -matchArmToExpr arm = - - let pat = Syntax.matchArmPattern arm - guard = Syntax.matchArmGuard arm - body = Syntax.matchArmBody arm - guardPart = - Optionals.match guard Nothing (\g -> Just (Serialization.spaceSep [ - Serialization.cst "if", - (expressionToExpr g)])) - in (Serialization.spaceSep (Optionals.givens [ - Just (patternToExpr pat), - guardPart, - (Just (Serialization.cst "=>")), - (Just (expressionToExpr body)), - (Just (Serialization.cst ","))])) - --- | Serialize a match expression -matchExprToExpr :: Syntax.MatchExpr -> Ast.Expr -matchExprToExpr m = - - let scrut = Syntax.matchExprScrutinee m - arms = Syntax.matchExprArms m - in (Serialization.spaceSep [ - Serialization.cst "match", - (expressionToExpr scrut), - (Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map matchArmToExpr arms))]) - --- | Serialize a method call expression -methodCallExprToExpr :: Syntax.MethodCallExpr -> Ast.Expr -methodCallExprToExpr m = - - let recv = Syntax.methodCallExprReceiver m - method = Syntax.methodCallExprMethod m - turbo = Syntax.methodCallExprTurbofish m - args = Syntax.methodCallExprArgs m - turboPart = - Logic.ifElse (Lists.isEmpty turbo) "" (Strings.concat [ - "::<", - (Strings.join ", " (Lists.map (\t -> Serialization.printExpr (typeToExpr t)) turbo)), - ">"]) - in (Serialization.cst (Strings.concat [ - Serialization.printExpr (expressionToExpr recv), - ".", - method, - turboPart, - "(", - (Strings.join ", " (Lists.map (\a -> Serialization.printExpr (expressionToExpr a)) args)), - ")"])) - --- | Serialize a method parameter -methodParamToExpr :: Syntax.MethodParam -> Ast.Expr -methodParamToExpr param = - case param of - Syntax.MethodParamSelf v0 -> case v0 of - Syntax.SelfParamOwned -> Serialization.cst "self" - Syntax.SelfParamRef -> Serialization.cst "&self" - Syntax.SelfParamRefMut -> Serialization.cst "&mut self" - Syntax.MethodParamRegular v0 -> fnParamToExpr v0 - --- | Serialize a module definition -modDefToExpr :: Syntax.ModDef -> Ast.Expr -modDefToExpr m = - - let name = Syntax.modDefName m - body = Syntax.modDefBody m - in (Optionals.match body (Serialization.spaceSep [ - Serialization.cst "mod", - (Serialization.cst name), - (Serialization.cst ";")]) (\items -> Serialization.spaceSep [ - Serialization.cst "mod", - (Serialization.cst name), - (Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map itemToExpr items))])) - --- | Serialize a path segment -pathSegmentToExpr :: Syntax.PathSegment -> Ast.Expr -pathSegmentToExpr seg = - - let name = Syntax.pathSegmentName seg - args = Syntax.pathSegmentArguments seg - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst name), - (genericArgumentsToExpr args)])) - --- | Serialize a pattern -patternToExpr :: Syntax.Pattern -> Ast.Expr -patternToExpr pat = - case pat of - Syntax.PatternWildcard -> Serialization.cst "_" - Syntax.PatternIdentifier v0 -> identifierPatternToExpr v0 - Syntax.PatternLiteral v0 -> literalToExpr v0 - Syntax.PatternReference v0 -> refPatternToExpr v0 - Syntax.PatternStruct v0 -> structPatternToExpr v0 - Syntax.PatternTupleStruct v0 -> tupleStructPatternToExpr v0 - Syntax.PatternTuple v0 -> Serialization.parenListAdaptive (Lists.map patternToExpr v0) - Syntax.PatternSlice v0 -> Serialization.bracketList Serialization.halfBlockStyle (Lists.map patternToExpr v0) - Syntax.PatternOr v0 -> Serialization.cst (Strings.join " | " (Lists.map (\p -> Serialization.printExpr (patternToExpr p)) v0)) - Syntax.PatternPath v0 -> exprPathToExpr v0 - Syntax.PatternRange v0 -> rangePatternToExpr v0 - Syntax.PatternRest -> Serialization.cst ".." - Syntax.PatternParen v0 -> Serialization.parenthesize (patternToExpr v0) - --- | Serialize a range expression -rangeExprToExpr :: Syntax.RangeExpr -> Ast.Expr -rangeExprToExpr r = - - let from = Syntax.rangeExprFrom r - to = Syntax.rangeExprTo r - incl = Syntax.rangeExprInclusive r - fromStr = Optionals.match from "" (\f -> Serialization.printExpr (expressionToExpr f)) - toStr = Optionals.match to "" (\t -> Serialization.printExpr (expressionToExpr t)) - op = Logic.ifElse incl "..=" ".." - in (Serialization.cst (Strings.concat [ - fromStr, - op, - toStr])) - --- | Serialize a range pattern -rangePatternToExpr :: Syntax.RangePattern -> Ast.Expr -rangePatternToExpr rp = - - let from = Syntax.rangePatternFrom rp - to = Syntax.rangePatternTo rp - incl = Syntax.rangePatternInclusive rp - fromStr = Optionals.match from "" (\p -> Serialization.printExpr (patternToExpr p)) - toStr = Optionals.match to "" (\p -> Serialization.printExpr (patternToExpr p)) - op = Logic.ifElse incl "..=" ".." - in (Serialization.cst (Strings.concat [ - fromStr, - op, - toStr])) - --- | Serialize a reference expression -refExprToExpr :: Syntax.RefExpr -> Ast.Expr -refExprToExpr r = - - let mut = Syntax.refExprMutable r - expr = Syntax.refExprExpr r - prefix = Logic.ifElse mut "&mut " "&" - in (Serialization.cst (Strings.concat2 prefix (Serialization.printExpr (expressionToExpr expr)))) - --- | Serialize a reference pattern -refPatternToExpr :: Syntax.RefPattern -> Ast.Expr -refPatternToExpr rp = - - let mut = Syntax.refPatternMutable rp - pat = Syntax.refPatternPattern rp - prefix = Logic.ifElse mut "&mut " "&" - in (Serialization.cst (Strings.concat2 prefix (Serialization.printExpr (patternToExpr pat)))) - --- | Serialize a reference type -referenceTypeToExpr :: Syntax.ReferenceType -> Ast.Expr -referenceTypeToExpr rt = - - let lt = Syntax.referenceTypeLifetime rt - mut = Syntax.referenceTypeMutable rt - t = Syntax.referenceTypeType rt - ltPart = Optionals.match lt "" (\l -> Strings.concat2 "'" (Strings.concat2 (Syntax.lifetimeName l) " ")) - mutPart = Logic.ifElse mut "mut " "" - in (Serialization.cst (Strings.concat [ - "&", - ltPart, - mutPart, - (Serialization.printExpr (typeToExpr t))])) - --- | Serialize a statement -statementToExpr :: Syntax.Statement -> Ast.Expr -statementToExpr stmt = - case stmt of - Syntax.StatementLet v0 -> letStatementToExpr v0 - Syntax.StatementExpression v0 -> Serialization.spaceSep [ - expressionToExpr v0, - (Serialization.cst ";")] - Syntax.StatementItem v0 -> itemToExpr v0 - Syntax.StatementEmpty -> Serialization.cst ";" - --- | Serialize a static definition -staticDefToExpr :: Syntax.StaticDef -> Ast.Expr -staticDefToExpr s = - - let name = Syntax.staticDefName s - typ = Syntax.staticDefType s - val = Syntax.staticDefValue s - mut = Syntax.staticDefMutable s - mutKw = Logic.ifElse mut (Just (Serialization.cst "mut")) Nothing - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "static"), - mutKw, - (Just (Serialization.cst (Strings.concat2 name ":"))), - (Just (typeToExpr typ)), - (Just (Serialization.cst "=")), - (Just (expressionToExpr val)), - (Just (Serialization.cst ";"))])) - --- | Serialize a struct body -structBodyToExpr :: Syntax.StructBody -> Ast.Expr -structBodyToExpr body = - case body of - Syntax.StructBodyNamed v0 -> Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map structFieldToExpr v0) - Syntax.StructBodyTuple v0 -> Serialization.spaceSep [ - Serialization.parenListAdaptive (Lists.map (\f -> typeToExpr (Syntax.tupleFieldType f)) v0), - (Serialization.cst ";")] - Syntax.StructBodyUnit -> Serialization.cst ";" - --- | Serialize a struct definition -structDefToExpr :: Syntax.StructDef -> Ast.Expr -structDefToExpr s = - - let name = Syntax.structDefName s - generics = Syntax.structDefGenerics s - whereC = Syntax.structDefWhereClause s - body = Syntax.structDefBody s - derives = Syntax.structDefDerives s - docC = Syntax.structDefDoc s - derivesAttr = derivesToExpr derives - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - header = - Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "struct"), - (Just (Serialization.cst name)), - (genericParamsToExpr generics)]) - wherePart = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - in (Serialization.newlineSep (Lists.concat [ - docPart, - (Optionals.match derivesAttr [] (\d -> [ - d])), - [ - Serialization.spaceSep (Optionals.givens [ - Just header, - wherePart, - (Just (structBodyToExpr body))])]])) - --- | Serialize a struct literal expression -structExprToExpr :: Syntax.StructExpr -> Ast.Expr -structExprToExpr s = - - let path = Syntax.structExprPath s - fields = Syntax.structExprFields s - rest = Syntax.structExprRest s - fieldExprs = Lists.map fieldValueToExpr fields - restExpr = - Optionals.match rest [] (\r -> [ - Serialization.spaceSep [ - Serialization.cst "..", - (expressionToExpr r)]]) - allFields = Lists.concat2 fieldExprs restExpr - in (Serialization.spaceSep [ - exprPathToExpr path, - (Serialization.curlyBracesList Nothing Serialization.halfBlockStyle allFields)]) - --- | Serialize a struct field -structFieldToExpr :: Syntax.StructField -> Ast.Expr -structFieldToExpr field = - - let name = Syntax.structFieldName field - typ = Syntax.structFieldType field - pub = Syntax.structFieldPublic field - docC = Syntax.structFieldDoc field - pubKw = Logic.ifElse pub (Just (Serialization.cst "pub")) Nothing - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep (Optionals.givens [ - pubKw, - (Just (Serialization.cst (Strings.concat2 name ":"))), - (Just (typeToExpr typ))])]])) - --- | Serialize a struct pattern -structPatternToExpr :: Syntax.StructPattern -> Ast.Expr -structPatternToExpr sp = - - let path = Syntax.structPatternPath sp - fields = Syntax.structPatternFields sp - rest = Syntax.structPatternRest sp - fieldExprs = Lists.map fieldPatternToExpr fields - restExpr = Logic.ifElse rest [ - Serialization.cst ".."] [] - allFields = Lists.concat2 fieldExprs restExpr - in (Serialization.spaceSep [ - exprPathToExpr path, - (Serialization.curlyBracesList Nothing Serialization.halfBlockStyle allFields)]) - --- | Convert a string to Rust line comments. Empty source lines emit `//` (no trailing space). -toRustComment :: String -> String -toRustComment c = - Strings.join "\n" (Lists.map (\s -> Logic.ifElse (Equality.equal s "") "//" (Strings.concat2 "// " s)) (Formatting.lines c)) - --- | Convert a string to Rust doc comments. Empty source lines emit `///` (no trailing space) so blank doc lines don't carry trailing whitespace. -toRustDocComment :: String -> String -toRustDocComment c = - Strings.join "\n" (Lists.map (\s -> Logic.ifElse (Equality.equal s "") "///" (Strings.concat2 "/// " s)) (Formatting.lines c)) - --- | Serialize a trait associated constant -traitConstToExpr :: Syntax.TraitConst -> Ast.Expr -traitConstToExpr c = - - let name = Syntax.traitConstName c - typ = Syntax.traitConstType c - def = Syntax.traitConstDefault c - defPart = - Optionals.match def Nothing (\d -> Just (Serialization.spaceSep [ - Serialization.cst "=", - (expressionToExpr d)])) - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "const"), - (Just (Serialization.cst (Strings.concat2 name ":"))), - (Just (typeToExpr typ)), - defPart, - (Just (Serialization.cst ";"))])) - --- | Serialize a trait definition -traitDefToExpr :: Syntax.TraitDef -> Ast.Expr -traitDefToExpr t = - - let name = Syntax.traitDefName t - generics = Syntax.traitDefGenerics t - whereC = Syntax.traitDefWhereClause t - supers = Syntax.traitDefSuperTraits t - items = Syntax.traitDefItems t - isUnsafe = Syntax.traitDefUnsafe t - docC = Syntax.traitDefDoc t - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - unsafeKw = Logic.ifElse isUnsafe (Just (Serialization.cst "unsafe")) Nothing - genericsExpr = genericParamsToExpr generics - superPart = - Logic.ifElse (Lists.isEmpty supers) Nothing (Just (Serialization.spaceSep [ - Serialization.cst ":", - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) supers)))])) - wherePart = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) - header = - Serialization.spaceSep (Optionals.givens [ - unsafeKw, - (Just (Serialization.cst "trait")), - (Just (Serialization.cst name)), - genericsExpr, - superPart, - wherePart]) - body = Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map traitItemToExpr items) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep [ - header, - body]]])) - --- | Serialize a trait item -traitItemToExpr :: Syntax.TraitItem -> Ast.Expr -traitItemToExpr item = - case item of - Syntax.TraitItemMethod v0 -> traitMethodToExpr v0 - Syntax.TraitItemType v0 -> traitTypeToExpr v0 - Syntax.TraitItemConst v0 -> traitConstToExpr v0 - --- | Serialize a trait method -traitMethodToExpr :: Syntax.TraitMethod -> Ast.Expr -traitMethodToExpr m = - - let name = Syntax.traitMethodName m - generics = Syntax.traitMethodGenerics m - params = Syntax.traitMethodParams m - retType = Syntax.traitMethodReturnType m - defBody = Syntax.traitMethodDefaultBody m - genericsExpr = genericParamsToExpr generics - paramsExpr = Serialization.parenListAdaptive (Lists.map methodParamToExpr params) - retTypeExpr = - Optionals.match retType Nothing (\t -> Just (Serialization.spaceSep [ - Serialization.cst "->", - (typeToExpr t)])) - header = - Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "fn"), - (Just (Serialization.cst name)), - genericsExpr, - (Just paramsExpr), - retTypeExpr]) - in (Optionals.match defBody (Serialization.spaceSep [ - header, - (Serialization.cst ";")]) (\body -> Serialization.spaceSep [ - header, - (blockToExpr body)])) - --- | Serialize a trait associated type -traitTypeToExpr :: Syntax.TraitType -> Ast.Expr -traitTypeToExpr t = - - let name = Syntax.traitTypeName t - bounds = Syntax.traitTypeBounds t - def = Syntax.traitTypeDefault t - boundsPart = - Logic.ifElse (Lists.isEmpty bounds) Nothing (Just (Serialization.spaceSep [ - Serialization.cst ":", - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) bounds)))])) - defPart = - Optionals.match def Nothing (\d -> Just (Serialization.spaceSep [ - Serialization.cst "=", - (typeToExpr d)])) - in (Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "type"), - (Just (Serialization.cst name)), - boundsPart, - defPart, - (Just (Serialization.cst ";"))])) - --- | Serialize a tuple index expression -tupleIndexExprToExpr :: Syntax.TupleIndexExpr -> Ast.Expr -tupleIndexExprToExpr t = - - let tuple = Syntax.tupleIndexExprTuple t - idx = Syntax.tupleIndexExprIndex t - in (Serialization.cst (Strings.concat [ - Serialization.printExpr (expressionToExpr tuple), - ".", - (Literals.printInt32 idx)])) - --- | Serialize a tuple struct pattern -tupleStructPatternToExpr :: Syntax.TupleStructPattern -> Ast.Expr -tupleStructPatternToExpr tsp = - - let path = Syntax.tupleStructPatternPath tsp - elems = Syntax.tupleStructPatternElements tsp - in (Serialization.spaceSep [ - exprPathToExpr path, - (Serialization.parenListAdaptive (Lists.map patternToExpr elems))]) - --- | Serialize a type alias -typeAliasToExpr :: Syntax.TypeAlias -> Ast.Expr -typeAliasToExpr ta = - - let name = Syntax.typeAliasName ta - generics = Syntax.typeAliasGenerics ta - typ = Syntax.typeAliasType ta - docC = Syntax.typeAliasDoc ta - docPart = Optionals.match docC [] (\d -> [ - Serialization.cst (toRustDocComment d)]) - in (Serialization.newlineSep (Lists.concat [ - docPart, - [ - Serialization.spaceSep (Optionals.givens [ - Just (Serialization.cst "type"), - (Just (Serialization.cst name)), - (genericParamsToExpr generics), - (Just (Serialization.cst "=")), - (Just (typeToExpr typ)), - (Just (Serialization.cst ";"))])]])) - --- | Serialize a type ascription expression -typeAscriptionExprToExpr :: Syntax.TypeAscriptionExpr -> Ast.Expr -typeAscriptionExprToExpr t = - - let expr = Syntax.typeAscriptionExprExpr t - typ = Syntax.typeAscriptionExprType t - in (Serialization.spaceSep [ - expressionToExpr expr, - (Serialization.cst ":"), - (typeToExpr typ)]) - --- | Serialize a type parameter bound -typeParamBoundToExpr :: Syntax.TypeParamBound -> Ast.Expr -typeParamBoundToExpr bound = - case bound of - Syntax.TypeParamBoundTrait v0 -> typePathToExpr v0 - Syntax.TypeParamBoundLifetime v0 -> Serialization.cst (Strings.concat2 "'" (Syntax.lifetimeName v0)) - --- | Serialize a type path -typePathToExpr :: Syntax.TypePath -> Ast.Expr -typePathToExpr tp = - - let global = Syntax.typePathGlobal tp - segs = Syntax.typePathSegments tp - prefix = Logic.ifElse global "::" "" - segStrs = Lists.map (\s -> Serialization.printExpr (pathSegmentToExpr s)) segs - in (Serialization.cst (Strings.concat2 prefix (Strings.join "::" segStrs))) - --- | Serialize a Rust type -typeToExpr :: Syntax.Type -> Ast.Expr -typeToExpr typ = - case typ of - Syntax.TypePath_ v0 -> typePathToExpr v0 - Syntax.TypeReference v0 -> referenceTypeToExpr v0 - Syntax.TypeSlice v0 -> Serialization.bracketList Serialization.inlineStyle [ - typeToExpr v0] - Syntax.TypeArray v0 -> - let elem = Syntax.arrayTypeElement v0 - len = Syntax.arrayTypeLength v0 - in (Serialization.cst (Strings.concat [ - "[", - (Serialization.printExpr (typeToExpr elem)), - "; ", - (Serialization.printExpr (expressionToExpr len)), - "]"])) - Syntax.TypeTuple v0 -> Serialization.parenListAdaptive (Lists.map typeToExpr v0) - Syntax.TypeFnPointer v0 -> - let params = Syntax.fnPointerTypeParams v0 - ret = Syntax.fnPointerTypeReturnType v0 - in (Serialization.spaceSep [ - Serialization.cst "fn", - (Serialization.parenListAdaptive (Lists.map typeToExpr params)), - (Serialization.cst "->"), - (typeToExpr ret)]) - Syntax.TypeImplTrait v0 -> Serialization.spaceSep [ - Serialization.cst "impl", - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) v0)))] - Syntax.TypeDynTrait v0 -> Serialization.spaceSep [ - Serialization.cst "dyn", - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) v0)))] - Syntax.TypeInferred -> Serialization.cst "_" - Syntax.TypeUnit -> Serialization.cst "()" - Syntax.TypeNever -> Serialization.cst "!" - Syntax.TypeRawPointer v0 -> - let mut = Syntax.rawPointerTypeMutable v0 - t = Syntax.rawPointerTypeType v0 - kw = Logic.ifElse mut "*mut" "*const" - in (Serialization.spaceSep [ - Serialization.cst kw, - (typeToExpr t)]) - Syntax.TypeMacro v0 -> macroInvocationToExpr v0 - --- | Serialize a unary expression -unaryExprToExpr :: Syntax.UnaryExpr -> Ast.Expr -unaryExprToExpr u = - - let op = Syntax.unaryExprOp u - operand = Syntax.unaryExprOperand u - opStr = - case op of - Syntax.UnaryOpNeg -> "-" - Syntax.UnaryOpNot -> "!" - in (Serialization.cst (Strings.concat2 opStr (Serialization.printExpr (expressionToExpr operand)))) - --- | Serialize a use declaration -useDeclarationToExpr :: Syntax.UseDeclaration -> Ast.Expr -useDeclarationToExpr use = - - let pub = Syntax.useDeclarationPublic use - tree = Syntax.useDeclarationTree use - pubKw = Logic.ifElse pub (Just (Serialization.cst "pub")) Nothing - in (Serialization.spaceSep (Optionals.givens [ - pubKw, - (Just (Serialization.cst "use")), - (Just (useTreeToExpr tree)), - (Just (Serialization.cst ";"))])) - --- | Serialize a use tree -useTreeToExpr :: Syntax.UseTree -> Ast.Expr -useTreeToExpr tree = - case tree of - Syntax.UseTreePath v0 -> Serialization.cst (Strings.join "::" (Syntax.usePathSegments v0)) - Syntax.UseTreeRename v0 -> - let path = Syntax.useRenamePath v0 - alias = Syntax.useRenameAlias v0 - in (Serialization.spaceSep [ - Serialization.cst (Strings.join "::" path), - (Serialization.cst "as"), - (Serialization.cst alias)]) - Syntax.UseTreeGlob v0 -> Serialization.cst (Strings.concat2 (Strings.join "::" v0) "::*") - Syntax.UseTreeGroup v0 -> - let prefix = Syntax.useGroupPrefix v0 - trees = Syntax.useGroupTrees v0 - prefixStr = Logic.ifElse (Lists.isEmpty prefix) "" (Strings.concat2 (Strings.join "::" prefix) "::") - in (Serialization.cst (Strings.concat [ - prefixStr, - "{", - (Strings.join ", " (Lists.map (\t -> Serialization.printExpr (useTreeToExpr t)) trees)), - "}"])) - --- | Serialize visibility to an optional expression -visibilityToExpr :: Syntax.Visibility -> Maybe Ast.Expr -visibilityToExpr vis = - case vis of - Syntax.VisibilityPublic -> Just (Serialization.cst "pub") - Syntax.VisibilityCrate -> Just (Serialization.cst "pub(crate)") - Syntax.VisibilityRestricted v0 -> Just (Serialization.cst (Strings.concat [ - "pub(in ", - (Strings.join "::" v0), - ")"])) - Syntax.VisibilityPrivate -> Nothing - --- | Serialize a where clause -whereClauseToExpr :: Syntax.WhereClause -> Ast.Expr -whereClauseToExpr wc = - - let preds = Syntax.whereClausePredicates wc - predExprs = - Lists.map (\p -> - let typ = Syntax.wherePredicateType p - bounds = Syntax.wherePredicateBounds p - in (Serialization.spaceSep [ - typeToExpr typ, - (Serialization.cst ":"), - (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) bounds)))])) preds - in (Serialization.spaceSep [ - Serialization.cst "where", - (Serialization.commaSep Serialization.inlineStyle predExprs)]) - --- | Serialize a while expression -whileExprToExpr :: Syntax.WhileExpr -> Ast.Expr -whileExprToExpr w = - - let label = Syntax.whileExprLabel w - cond = Syntax.whileExprCondition w - body = Syntax.whileExprBody w - labelPart = - Optionals.match label Nothing (\lbl -> Just (Serialization.cst (Strings.concat2 "'" (Strings.concat2 lbl ":")))) - condExpr = - case cond of - Syntax.IfConditionBool v0 -> expressionToExpr v0 - Syntax.IfConditionLet v0 -> - let pat = Syntax.letConditionPattern v0 - expr = Syntax.letConditionExpr v0 - in (Serialization.spaceSep [ - Serialization.cst "let", - (patternToExpr pat), - (Serialization.cst "="), - (expressionToExpr expr)]) - in (Serialization.spaceSep (Optionals.givens [ - labelPart, - (Just (Serialization.cst "while")), - (Just condExpr), - (Just (blockToExpr body))])) diff --git a/src/main/haskell/Hydra/Rust/Syntax.hs b/src/main/haskell/Hydra/Rust/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Rust/Syntax.hs +++ /dev/null @@ -1,2144 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A Rust syntax model, based on the Rust Reference grammar (https://doc.rust-lang.org/reference/), retrieved 2025-01-29 - -module Hydra.Rust.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.ByteString as B -import qualified Data.Int as I - --- | Angle-bracketed generic arguments -data AngleBracketedArgs = - AngleBracketedArgs { - -- | The generic arguments - angleBracketedArgsArgs :: [GenericArg]} - deriving (Eq, Ord, Read, Show) - -_AngleBracketedArgs = Core.Name "hydra.rust.syntax.AngleBracketedArgs" - -_AngleBracketedArgs_args = Core.Name "args" - --- | An array expression -data ArrayExpr = - -- | An array literal - ArrayExprElements [Expression] | - -- | An array repeat expression - ArrayExprRepeat ArrayRepeat - deriving (Eq, Ord, Read, Show) - -_ArrayExpr = Core.Name "hydra.rust.syntax.ArrayExpr" - -_ArrayExpr_elements = Core.Name "elements" - -_ArrayExpr_repeat = Core.Name "repeat" - --- | An array repeat expression (e.g., [0; 10]) -data ArrayRepeat = - ArrayRepeat { - -- | The element expression - arrayRepeatElement :: Expression, - -- | The length expression - arrayRepeatLength :: Expression} - deriving (Eq, Ord, Read, Show) - -_ArrayRepeat = Core.Name "hydra.rust.syntax.ArrayRepeat" - -_ArrayRepeat_element = Core.Name "element" - -_ArrayRepeat_length = Core.Name "length" - --- | An array type with a fixed size (e.g., [T; 3]) -data ArrayType = - ArrayType { - -- | The element type - arrayTypeElement :: Type, - -- | The array length (as a constant expression) - arrayTypeLength :: Expression} - deriving (Eq, Ord, Read, Show) - -_ArrayType = Core.Name "hydra.rust.syntax.ArrayType" - -_ArrayType_element = Core.Name "element" - -_ArrayType_length = Core.Name "length" - --- | An assignment expression -data AssignExpr = - AssignExpr { - -- | The left-hand side (target) - assignExprTarget :: Expression, - -- | The right-hand side (value) - assignExprValue :: Expression} - deriving (Eq, Ord, Read, Show) - -_AssignExpr = Core.Name "hydra.rust.syntax.AssignExpr" - -_AssignExpr_target = Core.Name "target" - -_AssignExpr_value = Core.Name "value" - --- | An attribute (e.g., #[derive(Clone)], #[cfg(test)]) -data Attribute = - Attribute { - -- | Whether the attribute is an inner attribute (#![...] vs #[...]) - attributeInner :: Bool, - -- | The attribute path - attributePath :: [String], - -- | The attribute arguments as a raw token string - attributeTokens :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Attribute = Core.Name "hydra.rust.syntax.Attribute" - -_Attribute_inner = Core.Name "inner" - -_Attribute_path = Core.Name "path" - -_Attribute_tokens = Core.Name "tokens" - --- | A binary operation -data BinaryExpr = - BinaryExpr { - -- | The left-hand operand - binaryExprLeft :: Expression, - -- | The binary operator - binaryExprOp :: BinaryOp, - -- | The right-hand operand - binaryExprRight :: Expression} - deriving (Eq, Ord, Read, Show) - -_BinaryExpr = Core.Name "hydra.rust.syntax.BinaryExpr" - -_BinaryExpr_left = Core.Name "left" - -_BinaryExpr_op = Core.Name "op" - -_BinaryExpr_right = Core.Name "right" - --- | A binary operator -data BinaryOp = - BinaryOpAdd | - BinaryOpSub | - BinaryOpMul | - BinaryOpDiv | - BinaryOpRem | - BinaryOpAnd | - BinaryOpOr | - BinaryOpBitAnd | - BinaryOpBitOr | - BinaryOpBitXor | - BinaryOpShl | - BinaryOpShr | - BinaryOpEq | - BinaryOpNe | - BinaryOpLt | - BinaryOpLe | - BinaryOpGt | - BinaryOpGe - deriving (Eq, Ord, Read, Show) - -_BinaryOp = Core.Name "hydra.rust.syntax.BinaryOp" - -_BinaryOp_add = Core.Name "add" - -_BinaryOp_sub = Core.Name "sub" - -_BinaryOp_mul = Core.Name "mul" - -_BinaryOp_div = Core.Name "div" - -_BinaryOp_rem = Core.Name "rem" - -_BinaryOp_and = Core.Name "and" - -_BinaryOp_or = Core.Name "or" - -_BinaryOp_bitAnd = Core.Name "bitAnd" - -_BinaryOp_bitOr = Core.Name "bitOr" - -_BinaryOp_bitXor = Core.Name "bitXor" - -_BinaryOp_shl = Core.Name "shl" - -_BinaryOp_shr = Core.Name "shr" - -_BinaryOp_eq = Core.Name "eq" - -_BinaryOp_ne = Core.Name "ne" - -_BinaryOp_lt = Core.Name "lt" - -_BinaryOp_le = Core.Name "le" - -_BinaryOp_gt = Core.Name "gt" - -_BinaryOp_ge = Core.Name "ge" - --- | A block expression -data Block = - Block { - -- | The statements in the block - blockStatements :: [Statement], - -- | An optional trailing expression - blockExpression :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_Block = Core.Name "hydra.rust.syntax.Block" - -_Block_statements = Core.Name "statements" - -_Block_expression = Core.Name "expression" - --- | A function call expression -data CallExpr = - CallExpr { - -- | The function being called - callExprFunction :: Expression, - -- | The arguments - callExprArgs :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_CallExpr = Core.Name "hydra.rust.syntax.CallExpr" - -_CallExpr_function = Core.Name "function" - -_CallExpr_args = Core.Name "args" - --- | A type cast expression -data CastExpr = - CastExpr { - -- | The expression being cast - castExprExpr :: Expression, - -- | The target type - castExprType :: Type} - deriving (Eq, Ord, Read, Show) - -_CastExpr = Core.Name "hydra.rust.syntax.CastExpr" - -_CastExpr_expr = Core.Name "expr" - -_CastExpr_type = Core.Name "type" - --- | A closure expression -data ClosureExpr = - ClosureExpr { - -- | Whether the closure captures by move - closureExprMove :: Bool, - -- | The closure parameters - closureExprParams :: [ClosureParam], - -- | Optional return type annotation - closureExprReturnType :: (Maybe Type), - -- | The closure body - closureExprBody :: Expression} - deriving (Eq, Ord, Read, Show) - -_ClosureExpr = Core.Name "hydra.rust.syntax.ClosureExpr" - -_ClosureExpr_move = Core.Name "move" - -_ClosureExpr_params = Core.Name "params" - -_ClosureExpr_returnType = Core.Name "returnType" - -_ClosureExpr_body = Core.Name "body" - --- | A closure parameter -data ClosureParam = - ClosureParam { - -- | The parameter pattern - closureParamPattern :: Pattern, - -- | Optional type annotation - closureParamType :: (Maybe Type)} - deriving (Eq, Ord, Read, Show) - -_ClosureParam = Core.Name "hydra.rust.syntax.ClosureParam" - -_ClosureParam_pattern = Core.Name "pattern" - -_ClosureParam_type = Core.Name "type" - --- | A compound assignment expression -data CompoundAssignExpr = - CompoundAssignExpr { - -- | The left-hand side (target) - compoundAssignExprTarget :: Expression, - -- | The compound assignment operator - compoundAssignExprOp :: CompoundAssignOp, - -- | The right-hand side (value) - compoundAssignExprValue :: Expression} - deriving (Eq, Ord, Read, Show) - -_CompoundAssignExpr = Core.Name "hydra.rust.syntax.CompoundAssignExpr" - -_CompoundAssignExpr_target = Core.Name "target" - -_CompoundAssignExpr_op = Core.Name "op" - -_CompoundAssignExpr_value = Core.Name "value" - --- | A compound assignment operator -data CompoundAssignOp = - CompoundAssignOpAddAssign | - CompoundAssignOpSubAssign | - CompoundAssignOpMulAssign | - CompoundAssignOpDivAssign | - CompoundAssignOpRemAssign | - CompoundAssignOpBitAndAssign | - CompoundAssignOpBitOrAssign | - CompoundAssignOpBitXorAssign | - CompoundAssignOpShlAssign | - CompoundAssignOpShrAssign - deriving (Eq, Ord, Read, Show) - -_CompoundAssignOp = Core.Name "hydra.rust.syntax.CompoundAssignOp" - -_CompoundAssignOp_addAssign = Core.Name "addAssign" - -_CompoundAssignOp_subAssign = Core.Name "subAssign" - -_CompoundAssignOp_mulAssign = Core.Name "mulAssign" - -_CompoundAssignOp_divAssign = Core.Name "divAssign" - -_CompoundAssignOp_remAssign = Core.Name "remAssign" - -_CompoundAssignOp_bitAndAssign = Core.Name "bitAndAssign" - -_CompoundAssignOp_bitOrAssign = Core.Name "bitOrAssign" - -_CompoundAssignOp_bitXorAssign = Core.Name "bitXorAssign" - -_CompoundAssignOp_shlAssign = Core.Name "shlAssign" - -_CompoundAssignOp_shrAssign = Core.Name "shrAssign" - --- | A constant item (e.g., const FOO: u32 = 42;) -data ConstDef = - ConstDef { - -- | The constant name - constDefName :: String, - -- | The constant type - constDefType :: Type, - -- | The constant value expression - constDefValue :: Expression, - -- | Whether the constant is public - constDefPublic :: Bool, - -- | Optional doc comment - constDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_ConstDef = Core.Name "hydra.rust.syntax.ConstDef" - -_ConstDef_name = Core.Name "name" - -_ConstDef_type = Core.Name "type" - -_ConstDef_value = Core.Name "value" - -_ConstDef_public = Core.Name "public" - -_ConstDef_doc = Core.Name "doc" - --- | A Rust crate, represented as a collection of top-level items -data Crate = - Crate { - -- | The top-level items in the crate - crateItems :: [ItemWithComments]} - deriving (Eq, Ord, Read, Show) - -_Crate = Core.Name "hydra.rust.syntax.Crate" - -_Crate_items = Core.Name "items" - --- | An enum definition (e.g., enum Foo { Bar(T), Baz { x: i32 } }) -data EnumDef = - EnumDef { - -- | The enum name - enumDefName :: String, - -- | Generic type parameters - enumDefGenerics :: [GenericParam], - -- | Optional where clause - enumDefWhereClause :: (Maybe WhereClause), - -- | The enum variants - enumDefVariants :: [EnumVariant], - -- | Derive macros to apply - enumDefDerives :: [String], - -- | Whether the enum is public - enumDefPublic :: Bool, - -- | Optional doc comment - enumDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_EnumDef = Core.Name "hydra.rust.syntax.EnumDef" - -_EnumDef_name = Core.Name "name" - -_EnumDef_generics = Core.Name "generics" - -_EnumDef_whereClause = Core.Name "whereClause" - -_EnumDef_variants = Core.Name "variants" - -_EnumDef_derives = Core.Name "derives" - -_EnumDef_public = Core.Name "public" - -_EnumDef_doc = Core.Name "doc" - --- | A variant of an enum definition -data EnumVariant = - EnumVariant { - -- | The variant name - enumVariantName :: String, - -- | The variant body - enumVariantBody :: EnumVariantBody, - -- | Optional doc comment for the variant - enumVariantDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_EnumVariant = Core.Name "hydra.rust.syntax.EnumVariant" - -_EnumVariant_name = Core.Name "name" - -_EnumVariant_body = Core.Name "body" - -_EnumVariant_doc = Core.Name "doc" - --- | The body of an enum variant -data EnumVariantBody = - -- | A unit variant (e.g., Foo) - EnumVariantBodyUnit | - -- | A tuple variant (e.g., Foo(i32, String)) - EnumVariantBodyTuple [Type] | - -- | A struct variant (e.g., Foo { x: i32 }) - EnumVariantBodyStruct [StructField] - deriving (Eq, Ord, Read, Show) - -_EnumVariantBody = Core.Name "hydra.rust.syntax.EnumVariantBody" - -_EnumVariantBody_unit = Core.Name "unit" - -_EnumVariantBody_tuple = Core.Name "tuple" - -_EnumVariantBody_struct = Core.Name "struct" - --- | A path used as an expression -data ExprPath = - ExprPath { - -- | Whether the path is global - exprPathGlobal :: Bool, - -- | The path segments - exprPathSegments :: [PathSegment]} - deriving (Eq, Ord, Read, Show) - -_ExprPath = Core.Name "hydra.rust.syntax.ExprPath" - -_ExprPath_global = Core.Name "global" - -_ExprPath_segments = Core.Name "segments" - --- | A Rust expression -data Expression = - -- | A literal value - ExpressionLiteral Literal | - -- | A path expression - ExpressionPath ExprPath | - -- | A block expression - ExpressionBlock Block | - -- | A function call expression - ExpressionCall CallExpr | - -- | A method call expression - ExpressionMethodCall MethodCallExpr | - -- | A field access expression - ExpressionFieldAccess FieldAccessExpr | - -- | A tuple index expression - ExpressionTupleIndex TupleIndexExpr | - -- | A closure expression - ExpressionClosure ClosureExpr | - -- | An if expression, including if let - ExpressionIf IfExpr | - -- | A match expression - ExpressionMatch MatchExpr | - -- | A loop expression - ExpressionLoop LoopExpr | - -- | A while expression, including while let - ExpressionWhile WhileExpr | - -- | A for expression - ExpressionFor ForExpr | - -- | A binary operation - ExpressionBinary BinaryExpr | - -- | A unary operation - ExpressionUnary UnaryExpr | - -- | A reference expression - ExpressionReference RefExpr | - -- | A dereference expression - ExpressionDereference Expression | - -- | A struct literal expression - ExpressionStruct StructExpr | - -- | A tuple expression - ExpressionTuple [Expression] | - -- | An array expression - ExpressionArray ArrayExpr | - -- | An index expression - ExpressionIndex IndexExpr | - -- | A range expression - ExpressionRange RangeExpr | - -- | A return expression - ExpressionReturn (Maybe Expression) | - -- | A break expression - ExpressionBreak (Maybe Expression) | - -- | A continue expression - ExpressionContinue | - -- | A try expression (expr?) - ExpressionTry Expression | - -- | A type cast expression - ExpressionCast CastExpr | - -- | A type ascription expression - ExpressionTypeAscription TypeAscriptionExpr | - -- | An await expression - ExpressionAwait Expression | - -- | An assignment expression - ExpressionAssign AssignExpr | - -- | A compound assignment expression - ExpressionCompoundAssign CompoundAssignExpr | - -- | A macro invocation expression - ExpressionMacro MacroInvocation | - -- | A parenthesized expression - ExpressionParen Expression - deriving (Eq, Ord, Read, Show) - -_Expression = Core.Name "hydra.rust.syntax.Expression" - -_Expression_literal = Core.Name "literal" - -_Expression_path = Core.Name "path" - -_Expression_block = Core.Name "block" - -_Expression_call = Core.Name "call" - -_Expression_methodCall = Core.Name "methodCall" - -_Expression_fieldAccess = Core.Name "fieldAccess" - -_Expression_tupleIndex = Core.Name "tupleIndex" - -_Expression_closure = Core.Name "closure" - -_Expression_if = Core.Name "if" - -_Expression_match = Core.Name "match" - -_Expression_loop = Core.Name "loop" - -_Expression_while = Core.Name "while" - -_Expression_for = Core.Name "for" - -_Expression_binary = Core.Name "binary" - -_Expression_unary = Core.Name "unary" - -_Expression_reference = Core.Name "reference" - -_Expression_dereference = Core.Name "dereference" - -_Expression_struct = Core.Name "struct" - -_Expression_tuple = Core.Name "tuple" - -_Expression_array = Core.Name "array" - -_Expression_index = Core.Name "index" - -_Expression_range = Core.Name "range" - -_Expression_return = Core.Name "return" - -_Expression_break = Core.Name "break" - -_Expression_continue = Core.Name "continue" - -_Expression_try = Core.Name "try" - -_Expression_cast = Core.Name "cast" - -_Expression_typeAscription = Core.Name "typeAscription" - -_Expression_await = Core.Name "await" - -_Expression_assign = Core.Name "assign" - -_Expression_compoundAssign = Core.Name "compoundAssign" - -_Expression_macro = Core.Name "macro" - -_Expression_paren = Core.Name "paren" - --- | A field access expression -data FieldAccessExpr = - FieldAccessExpr { - -- | The expression being accessed - fieldAccessExprObject :: Expression, - -- | The field name - fieldAccessExprField :: String} - deriving (Eq, Ord, Read, Show) - -_FieldAccessExpr = Core.Name "hydra.rust.syntax.FieldAccessExpr" - -_FieldAccessExpr_object = Core.Name "object" - -_FieldAccessExpr_field = Core.Name "field" - --- | A field pattern within a struct pattern -data FieldPattern = - FieldPattern { - -- | The field name - fieldPatternName :: String, - -- | The field pattern (None for shorthand) - fieldPatternPattern :: (Maybe Pattern)} - deriving (Eq, Ord, Read, Show) - -_FieldPattern = Core.Name "hydra.rust.syntax.FieldPattern" - -_FieldPattern_name = Core.Name "name" - -_FieldPattern_pattern = Core.Name "pattern" - --- | A field-value pair in a struct literal -data FieldValue = - FieldValue { - -- | The field name - fieldValueName :: String, - -- | The field value (None for shorthand syntax) - fieldValueValue :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_FieldValue = Core.Name "hydra.rust.syntax.FieldValue" - -_FieldValue_name = Core.Name "name" - -_FieldValue_value = Core.Name "value" - --- | A floating-point literal with optional suffix -data FloatLiteral = - FloatLiteral { - -- | The float value - floatLiteralValue :: Double, - -- | Optional type suffix - floatLiteralSuffix :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_FloatLiteral = Core.Name "hydra.rust.syntax.FloatLiteral" - -_FloatLiteral_value = Core.Name "value" - -_FloatLiteral_suffix = Core.Name "suffix" - --- | A function definition (e.g., fn foo(x: T) -> String { ... }) -data FnDef = - FnDef { - -- | The function name - fnDefName :: String, - -- | Generic type parameters - fnDefGenerics :: [GenericParam], - -- | Optional where clause - fnDefWhereClause :: (Maybe WhereClause), - -- | The function parameters - fnDefParams :: [FnParam], - -- | The return type (None means ()) - fnDefReturnType :: (Maybe Type), - -- | The function body - fnDefBody :: Block, - -- | Whether the function is public - fnDefPublic :: Bool, - -- | Whether the function is async - fnDefAsync :: Bool, - -- | Whether the function is const - fnDefConst :: Bool, - -- | Whether the function is unsafe - fnDefUnsafe :: Bool, - -- | Optional doc comment - fnDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_FnDef = Core.Name "hydra.rust.syntax.FnDef" - -_FnDef_name = Core.Name "name" - -_FnDef_generics = Core.Name "generics" - -_FnDef_whereClause = Core.Name "whereClause" - -_FnDef_params = Core.Name "params" - -_FnDef_returnType = Core.Name "returnType" - -_FnDef_body = Core.Name "body" - -_FnDef_public = Core.Name "public" - -_FnDef_async = Core.Name "async" - -_FnDef_const = Core.Name "const" - -_FnDef_unsafe = Core.Name "unsafe" - -_FnDef_doc = Core.Name "doc" - --- | A function parameter -data FnParam = - FnParam { - -- | The parameter pattern - fnParamPattern :: Pattern, - -- | The parameter type - fnParamType :: Type} - deriving (Eq, Ord, Read, Show) - -_FnParam = Core.Name "hydra.rust.syntax.FnParam" - -_FnParam_pattern = Core.Name "pattern" - -_FnParam_type = Core.Name "type" - --- | A function pointer type (e.g., fn(i32, i32) -> i32) -data FnPointerType = - FnPointerType { - -- | The parameter types - fnPointerTypeParams :: [Type], - -- | The return type - fnPointerTypeReturnType :: Type} - deriving (Eq, Ord, Read, Show) - -_FnPointerType = Core.Name "hydra.rust.syntax.FnPointerType" - -_FnPointerType_params = Core.Name "params" - -_FnPointerType_returnType = Core.Name "returnType" - --- | A for expression -data ForExpr = - ForExpr { - -- | Optional loop label - forExprLabel :: (Maybe String), - -- | The loop variable pattern - forExprPattern :: Pattern, - -- | The iterator expression - forExprIter :: Expression, - -- | The loop body - forExprBody :: Block} - deriving (Eq, Ord, Read, Show) - -_ForExpr = Core.Name "hydra.rust.syntax.ForExpr" - -_ForExpr_label = Core.Name "label" - -_ForExpr_pattern = Core.Name "pattern" - -_ForExpr_iter = Core.Name "iter" - -_ForExpr_body = Core.Name "body" - --- | A single generic argument -data GenericArg = - -- | A type argument - GenericArgType Type | - -- | A lifetime argument - GenericArgLifetime Lifetime | - -- | A const expression argument - GenericArgConst Expression | - -- | An associated type binding - GenericArgBinding TypeBinding - deriving (Eq, Ord, Read, Show) - -_GenericArg = Core.Name "hydra.rust.syntax.GenericArg" - -_GenericArg_type = Core.Name "type" - -_GenericArg_lifetime = Core.Name "lifetime" - -_GenericArg_const = Core.Name "const" - -_GenericArg_binding = Core.Name "binding" - --- | Generic arguments to a path segment -data GenericArguments = - -- | No generic arguments - GenericArgumentsNone | - -- | Angle-bracketed arguments - GenericArgumentsAngleBracketed AngleBracketedArgs | - -- | Parenthesized arguments for Fn traits - GenericArgumentsParenthesized ParenthesizedArgs - deriving (Eq, Ord, Read, Show) - -_GenericArguments = Core.Name "hydra.rust.syntax.GenericArguments" - -_GenericArguments_none = Core.Name "none" - -_GenericArguments_angleBracketed = Core.Name "angleBracketed" - -_GenericArguments_parenthesized = Core.Name "parenthesized" - --- | A generic type parameter (e.g., T: Clone + Debug) -data GenericParam = - GenericParam { - -- | The parameter name - genericParamName :: String, - -- | Trait bounds on the parameter - genericParamBounds :: [TypeParamBound]} - deriving (Eq, Ord, Read, Show) - -_GenericParam = Core.Name "hydra.rust.syntax.GenericParam" - -_GenericParam_name = Core.Name "name" - -_GenericParam_bounds = Core.Name "bounds" - --- | An identifier pattern -data IdentifierPattern = - IdentifierPattern { - -- | The identifier name - identifierPatternName :: String, - -- | Whether the binding is mutable - identifierPatternMutable :: Bool, - -- | Optional sub-pattern (e.g., x @ Some(_)) - identifierPatternAtPattern :: (Maybe Pattern)} - deriving (Eq, Ord, Read, Show) - -_IdentifierPattern = Core.Name "hydra.rust.syntax.IdentifierPattern" - -_IdentifierPattern_name = Core.Name "name" - -_IdentifierPattern_mutable = Core.Name "mutable" - -_IdentifierPattern_atPattern = Core.Name "atPattern" - --- | The condition of an if expression -data IfCondition = - -- | A boolean condition - IfConditionBool Expression | - -- | A let condition - IfConditionLet LetCondition - deriving (Eq, Ord, Read, Show) - -_IfCondition = Core.Name "hydra.rust.syntax.IfCondition" - -_IfCondition_bool = Core.Name "bool" - -_IfCondition_let = Core.Name "let" - --- | An if expression, optionally with if let -data IfExpr = - IfExpr { - -- | The condition - ifExprCondition :: IfCondition, - -- | The then block - ifExprThenBlock :: Block, - -- | An optional else branch - ifExprElseBranch :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_IfExpr = Core.Name "hydra.rust.syntax.IfExpr" - -_IfExpr_condition = Core.Name "condition" - -_IfExpr_thenBlock = Core.Name "thenBlock" - -_IfExpr_elseBranch = Core.Name "elseBranch" - --- | An impl block (e.g., impl Trait for Foo { ... }) -data ImplBlock = - ImplBlock { - -- | Generic type parameters - implBlockGenerics :: [GenericParam], - -- | Optional where clause - implBlockWhereClause :: (Maybe WhereClause), - -- | The trait being implemented, if any - implBlockTrait :: (Maybe TypePath), - -- | Whether this is a negative impl - implBlockNegative :: Bool, - -- | The type being implemented for - implBlockSelfType :: Type, - -- | The items within the impl block - implBlockItems :: [ImplItem]} - deriving (Eq, Ord, Read, Show) - -_ImplBlock = Core.Name "hydra.rust.syntax.ImplBlock" - -_ImplBlock_generics = Core.Name "generics" - -_ImplBlock_whereClause = Core.Name "whereClause" - -_ImplBlock_trait = Core.Name "trait" - -_ImplBlock_negative = Core.Name "negative" - -_ImplBlock_selfType = Core.Name "selfType" - -_ImplBlock_items = Core.Name "items" - --- | An item within an impl block -data ImplItem = - -- | A method definition - ImplItemMethod ImplMethod | - -- | An associated type definition - ImplItemType TypeAlias | - -- | An associated constant - ImplItemConst ConstDef - deriving (Eq, Ord, Read, Show) - -_ImplItem = Core.Name "hydra.rust.syntax.ImplItem" - -_ImplItem_method = Core.Name "method" - -_ImplItem_type = Core.Name "type" - -_ImplItem_const = Core.Name "const" - --- | A method within an impl block -data ImplMethod = - ImplMethod { - -- | The method name - implMethodName :: String, - -- | Generic type parameters - implMethodGenerics :: [GenericParam], - -- | Optional where clause - implMethodWhereClause :: (Maybe WhereClause), - -- | The method parameters (including self) - implMethodParams :: [MethodParam], - -- | The return type (None means ()) - implMethodReturnType :: (Maybe Type), - -- | The method body - implMethodBody :: Block, - -- | Whether the method is public - implMethodPublic :: Bool, - -- | Whether the method has a default implementation - implMethodDefault :: Bool, - -- | Optional doc comment - implMethodDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_ImplMethod = Core.Name "hydra.rust.syntax.ImplMethod" - -_ImplMethod_name = Core.Name "name" - -_ImplMethod_generics = Core.Name "generics" - -_ImplMethod_whereClause = Core.Name "whereClause" - -_ImplMethod_params = Core.Name "params" - -_ImplMethod_returnType = Core.Name "returnType" - -_ImplMethod_body = Core.Name "body" - -_ImplMethod_public = Core.Name "public" - -_ImplMethod_default = Core.Name "default" - -_ImplMethod_doc = Core.Name "doc" - --- | An index expression -data IndexExpr = - IndexExpr { - -- | The expression being indexed - indexExprObject :: Expression, - -- | The index expression - indexExprIndex :: Expression} - deriving (Eq, Ord, Read, Show) - -_IndexExpr = Core.Name "hydra.rust.syntax.IndexExpr" - -_IndexExpr_object = Core.Name "object" - -_IndexExpr_index = Core.Name "index" - --- | An integer literal with optional suffix -data IntegerLiteral = - IntegerLiteral { - -- | The integer value - integerLiteralValue :: Integer, - -- | Optional type suffix - integerLiteralSuffix :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_IntegerLiteral = Core.Name "hydra.rust.syntax.IntegerLiteral" - -_IntegerLiteral_value = Core.Name "value" - -_IntegerLiteral_suffix = Core.Name "suffix" - --- | A top-level item in a Rust module or crate -data Item = - -- | A use declaration - ItemUse UseDeclaration | - -- | A struct definition - ItemStruct StructDef | - -- | An enum definition - ItemEnum EnumDef | - -- | A function definition - ItemFn FnDef | - -- | A type alias - ItemTypeAlias TypeAlias | - -- | An impl block - ItemImpl ImplBlock | - -- | A trait definition - ItemTrait TraitDef | - -- | A module definition - ItemMod ModDef | - -- | A constant item - ItemConst ConstDef | - -- | A static item - ItemStatic StaticDef | - -- | A macro invocation as an item - ItemMacro MacroInvocation - deriving (Eq, Ord, Read, Show) - -_Item = Core.Name "hydra.rust.syntax.Item" - -_Item_use = Core.Name "use" - -_Item_struct = Core.Name "struct" - -_Item_enum = Core.Name "enum" - -_Item_fn = Core.Name "fn" - -_Item_typeAlias = Core.Name "typeAlias" - -_Item_impl = Core.Name "impl" - -_Item_trait = Core.Name "trait" - -_Item_mod = Core.Name "mod" - -_Item_const = Core.Name "const" - -_Item_static = Core.Name "static" - -_Item_macro = Core.Name "macro" - --- | An item together with optional doc comments and visibility -data ItemWithComments = - ItemWithComments { - -- | Optional documentation comment - itemWithCommentsDoc :: (Maybe String), - -- | The item's visibility - itemWithCommentsVisibility :: Visibility, - -- | The item itself - itemWithCommentsItem :: Item} - deriving (Eq, Ord, Read, Show) - -_ItemWithComments = Core.Name "hydra.rust.syntax.ItemWithComments" - -_ItemWithComments_doc = Core.Name "doc" - -_ItemWithComments_visibility = Core.Name "visibility" - -_ItemWithComments_item = Core.Name "item" - --- | A let condition (e.g., let Some(x) = opt) -data LetCondition = - LetCondition { - -- | The pattern - letConditionPattern :: Pattern, - -- | The expression being matched - letConditionExpr :: Expression} - deriving (Eq, Ord, Read, Show) - -_LetCondition = Core.Name "hydra.rust.syntax.LetCondition" - -_LetCondition_pattern = Core.Name "pattern" - -_LetCondition_expr = Core.Name "expr" - --- | A let statement -data LetStatement = - LetStatement { - -- | The binding pattern - letStatementPattern :: Pattern, - -- | Whether the binding is mutable - letStatementMutable :: Bool, - -- | Optional type annotation - letStatementType :: (Maybe Type), - -- | Optional initializer expression - letStatementInit :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_LetStatement = Core.Name "hydra.rust.syntax.LetStatement" - -_LetStatement_pattern = Core.Name "pattern" - -_LetStatement_mutable = Core.Name "mutable" - -_LetStatement_type = Core.Name "type" - -_LetStatement_init = Core.Name "init" - --- | A lifetime (e.g., 'a, 'static) -data Lifetime = - Lifetime { - -- | The lifetime name (without the leading quote) - lifetimeName :: String} - deriving (Eq, Ord, Read, Show) - -_Lifetime = Core.Name "hydra.rust.syntax.Lifetime" - -_Lifetime_name = Core.Name "name" - --- | A literal value -data Literal = - -- | An integer literal - LiteralInteger IntegerLiteral | - -- | A floating-point literal - LiteralFloat FloatLiteral | - -- | A string literal - LiteralString String | - -- | A raw string literal - LiteralRawString String | - -- | A byte string literal - LiteralByteString B.ByteString | - -- | A character literal - LiteralChar I.Int64 | - -- | A byte literal - LiteralByte I.Int16 | - -- | A boolean literal - LiteralBool Bool - deriving (Eq, Ord, Read, Show) - -_Literal = Core.Name "hydra.rust.syntax.Literal" - -_Literal_integer = Core.Name "integer" - -_Literal_float = Core.Name "float" - -_Literal_string = Core.Name "string" - -_Literal_rawString = Core.Name "rawString" - -_Literal_byteString = Core.Name "byteString" - -_Literal_char = Core.Name "char" - -_Literal_byte = Core.Name "byte" - -_Literal_bool = Core.Name "bool" - --- | A loop expression -data LoopExpr = - LoopExpr { - -- | Optional loop label - loopExprLabel :: (Maybe String), - -- | The loop body - loopExprBody :: Block} - deriving (Eq, Ord, Read, Show) - -_LoopExpr = Core.Name "hydra.rust.syntax.LoopExpr" - -_LoopExpr_label = Core.Name "label" - -_LoopExpr_body = Core.Name "body" - --- | The delimiter style for a macro invocation -data MacroDelimiter = - MacroDelimiterParen | - MacroDelimiterBracket | - MacroDelimiterBrace - deriving (Eq, Ord, Read, Show) - -_MacroDelimiter = Core.Name "hydra.rust.syntax.MacroDelimiter" - -_MacroDelimiter_paren = Core.Name "paren" - -_MacroDelimiter_bracket = Core.Name "bracket" - -_MacroDelimiter_brace = Core.Name "brace" - --- | A macro invocation -data MacroInvocation = - MacroInvocation { - -- | The macro path - macroInvocationPath :: [String], - -- | The delimiter style used - macroInvocationDelimiter :: MacroDelimiter, - -- | The token stream as a raw string - macroInvocationTokens :: String} - deriving (Eq, Ord, Read, Show) - -_MacroInvocation = Core.Name "hydra.rust.syntax.MacroInvocation" - -_MacroInvocation_path = Core.Name "path" - -_MacroInvocation_delimiter = Core.Name "delimiter" - -_MacroInvocation_tokens = Core.Name "tokens" - --- | A single arm in a match expression -data MatchArm = - MatchArm { - -- | The pattern to match - matchArmPattern :: Pattern, - -- | Optional guard expression - matchArmGuard :: (Maybe Expression), - -- | The body expression - matchArmBody :: Expression} - deriving (Eq, Ord, Read, Show) - -_MatchArm = Core.Name "hydra.rust.syntax.MatchArm" - -_MatchArm_pattern = Core.Name "pattern" - -_MatchArm_guard = Core.Name "guard" - -_MatchArm_body = Core.Name "body" - --- | A match expression -data MatchExpr = - MatchExpr { - -- | The expression being matched - matchExprScrutinee :: Expression, - -- | The match arms - matchExprArms :: [MatchArm]} - deriving (Eq, Ord, Read, Show) - -_MatchExpr = Core.Name "hydra.rust.syntax.MatchExpr" - -_MatchExpr_scrutinee = Core.Name "scrutinee" - -_MatchExpr_arms = Core.Name "arms" - --- | A method call expression -data MethodCallExpr = - MethodCallExpr { - -- | The receiver expression - methodCallExprReceiver :: Expression, - -- | The method name - methodCallExprMethod :: String, - -- | Optional turbofish generic arguments - methodCallExprTurbofish :: [Type], - -- | The arguments (excluding the receiver) - methodCallExprArgs :: [Expression]} - deriving (Eq, Ord, Read, Show) - -_MethodCallExpr = Core.Name "hydra.rust.syntax.MethodCallExpr" - -_MethodCallExpr_receiver = Core.Name "receiver" - -_MethodCallExpr_method = Core.Name "method" - -_MethodCallExpr_turbofish = Core.Name "turbofish" - -_MethodCallExpr_args = Core.Name "args" - --- | A method parameter, which may be self or a regular parameter -data MethodParam = - -- | A self parameter - MethodParamSelf SelfParam | - -- | A regular function parameter - MethodParamRegular FnParam - deriving (Eq, Ord, Read, Show) - -_MethodParam = Core.Name "hydra.rust.syntax.MethodParam" - -_MethodParam_self = Core.Name "self" - -_MethodParam_regular = Core.Name "regular" - --- | A module definition (either inline or external) -data ModDef = - ModDef { - -- | The module name - modDefName :: String, - -- | The module body (None for external file) - modDefBody :: (Maybe [Item]), - -- | Whether the module is public - modDefPublic :: Bool, - -- | Optional doc comment - modDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_ModDef = Core.Name "hydra.rust.syntax.ModDef" - -_ModDef_name = Core.Name "name" - -_ModDef_body = Core.Name "body" - -_ModDef_public = Core.Name "public" - -_ModDef_doc = Core.Name "doc" - --- | Parenthesized generic arguments for Fn traits -data ParenthesizedArgs = - ParenthesizedArgs { - -- | The input types - parenthesizedArgsInputs :: [Type], - -- | The output type - parenthesizedArgsOutput :: (Maybe Type)} - deriving (Eq, Ord, Read, Show) - -_ParenthesizedArgs = Core.Name "hydra.rust.syntax.ParenthesizedArgs" - -_ParenthesizedArgs_inputs = Core.Name "inputs" - -_ParenthesizedArgs_output = Core.Name "output" - --- | A segment within a type path -data PathSegment = - PathSegment { - -- | The segment name - pathSegmentName :: String, - -- | Generic arguments, if any - pathSegmentArguments :: GenericArguments} - deriving (Eq, Ord, Read, Show) - -_PathSegment = Core.Name "hydra.rust.syntax.PathSegment" - -_PathSegment_name = Core.Name "name" - -_PathSegment_arguments = Core.Name "arguments" - --- | A Rust pattern (used in let, match, function parameters, etc.) -data Pattern = - -- | A wildcard pattern (_) - PatternWildcard | - -- | An identifier pattern - PatternIdentifier IdentifierPattern | - -- | A literal pattern - PatternLiteral Literal | - -- | A reference pattern - PatternReference RefPattern | - -- | A struct pattern - PatternStruct StructPattern | - -- | A tuple struct pattern - PatternTupleStruct TupleStructPattern | - -- | A tuple pattern - PatternTuple [Pattern] | - -- | A slice pattern - PatternSlice [Pattern] | - -- | An or-pattern - PatternOr [Pattern] | - -- | A path pattern - PatternPath ExprPath | - -- | A range pattern - PatternRange RangePattern | - -- | A rest pattern (..) - PatternRest | - -- | A parenthesized pattern - PatternParen Pattern - deriving (Eq, Ord, Read, Show) - -_Pattern = Core.Name "hydra.rust.syntax.Pattern" - -_Pattern_wildcard = Core.Name "wildcard" - -_Pattern_identifier = Core.Name "identifier" - -_Pattern_literal = Core.Name "literal" - -_Pattern_reference = Core.Name "reference" - -_Pattern_struct = Core.Name "struct" - -_Pattern_tupleStruct = Core.Name "tupleStruct" - -_Pattern_tuple = Core.Name "tuple" - -_Pattern_slice = Core.Name "slice" - -_Pattern_or = Core.Name "or" - -_Pattern_path = Core.Name "path" - -_Pattern_range = Core.Name "range" - -_Pattern_rest = Core.Name "rest" - -_Pattern_paren = Core.Name "paren" - --- | A range expression -data RangeExpr = - RangeExpr { - -- | The lower bound (optional) - rangeExprFrom :: (Maybe Expression), - -- | The upper bound (optional) - rangeExprTo :: (Maybe Expression), - -- | Whether the range is inclusive - rangeExprInclusive :: Bool} - deriving (Eq, Ord, Read, Show) - -_RangeExpr = Core.Name "hydra.rust.syntax.RangeExpr" - -_RangeExpr_from = Core.Name "from" - -_RangeExpr_to = Core.Name "to" - -_RangeExpr_inclusive = Core.Name "inclusive" - --- | A range pattern -data RangePattern = - RangePattern { - -- | The lower bound - rangePatternFrom :: (Maybe Pattern), - -- | The upper bound - rangePatternTo :: (Maybe Pattern), - -- | Whether the range is inclusive - rangePatternInclusive :: Bool} - deriving (Eq, Ord, Read, Show) - -_RangePattern = Core.Name "hydra.rust.syntax.RangePattern" - -_RangePattern_from = Core.Name "from" - -_RangePattern_to = Core.Name "to" - -_RangePattern_inclusive = Core.Name "inclusive" - --- | A raw pointer type (e.g., *const T, *mut T) -data RawPointerType = - RawPointerType { - -- | Whether the pointer is mutable (*mut vs *const) - rawPointerTypeMutable :: Bool, - -- | The pointed-to type - rawPointerTypeType :: Type} - deriving (Eq, Ord, Read, Show) - -_RawPointerType = Core.Name "hydra.rust.syntax.RawPointerType" - -_RawPointerType_mutable = Core.Name "mutable" - -_RawPointerType_type = Core.Name "type" - --- | A reference expression -data RefExpr = - RefExpr { - -- | Whether the reference is mutable - refExprMutable :: Bool, - -- | The expression being referenced - refExprExpr :: Expression} - deriving (Eq, Ord, Read, Show) - -_RefExpr = Core.Name "hydra.rust.syntax.RefExpr" - -_RefExpr_mutable = Core.Name "mutable" - -_RefExpr_expr = Core.Name "expr" - --- | A reference pattern -data RefPattern = - RefPattern { - -- | Whether the reference is mutable - refPatternMutable :: Bool, - -- | The inner pattern - refPatternPattern :: Pattern} - deriving (Eq, Ord, Read, Show) - -_RefPattern = Core.Name "hydra.rust.syntax.RefPattern" - -_RefPattern_mutable = Core.Name "mutable" - -_RefPattern_pattern = Core.Name "pattern" - --- | A reference type (e.g., &T, &mut T, &'a T) -data ReferenceType = - ReferenceType { - -- | Optional lifetime annotation - referenceTypeLifetime :: (Maybe Lifetime), - -- | Whether the reference is mutable - referenceTypeMutable :: Bool, - -- | The referenced type - referenceTypeType :: Type} - deriving (Eq, Ord, Read, Show) - -_ReferenceType = Core.Name "hydra.rust.syntax.ReferenceType" - -_ReferenceType_lifetime = Core.Name "lifetime" - -_ReferenceType_mutable = Core.Name "mutable" - -_ReferenceType_type = Core.Name "type" - --- | A self parameter in a method -data SelfParam = - SelfParamOwned | - SelfParamRef | - SelfParamRefMut - deriving (Eq, Ord, Read, Show) - -_SelfParam = Core.Name "hydra.rust.syntax.SelfParam" - -_SelfParam_owned = Core.Name "owned" - -_SelfParam_ref = Core.Name "ref" - -_SelfParam_refMut = Core.Name "refMut" - --- | A statement within a block -data Statement = - -- | A let binding - StatementLet LetStatement | - -- | An expression statement - StatementExpression Expression | - -- | An item declaration within a block - StatementItem Item | - -- | An empty statement - StatementEmpty - deriving (Eq, Ord, Read, Show) - -_Statement = Core.Name "hydra.rust.syntax.Statement" - -_Statement_let = Core.Name "let" - -_Statement_expression = Core.Name "expression" - -_Statement_item = Core.Name "item" - -_Statement_empty = Core.Name "empty" - --- | A static item (e.g., static FOO: u32 = 42;) -data StaticDef = - StaticDef { - -- | The static name - staticDefName :: String, - -- | The static type - staticDefType :: Type, - -- | The static value expression - staticDefValue :: Expression, - -- | Whether the static is mutable - staticDefMutable :: Bool, - -- | Whether the static is public - staticDefPublic :: Bool, - -- | Optional doc comment - staticDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_StaticDef = Core.Name "hydra.rust.syntax.StaticDef" - -_StaticDef_name = Core.Name "name" - -_StaticDef_type = Core.Name "type" - -_StaticDef_value = Core.Name "value" - -_StaticDef_mutable = Core.Name "mutable" - -_StaticDef_public = Core.Name "public" - -_StaticDef_doc = Core.Name "doc" - --- | The body of a struct definition -data StructBody = - -- | A struct with named fields - StructBodyNamed [StructField] | - -- | A tuple struct - StructBodyTuple [TupleField] | - -- | A unit struct - StructBodyUnit - deriving (Eq, Ord, Read, Show) - -_StructBody = Core.Name "hydra.rust.syntax.StructBody" - -_StructBody_named = Core.Name "named" - -_StructBody_tuple = Core.Name "tuple" - -_StructBody_unit = Core.Name "unit" - --- | A struct definition (e.g., struct Foo { bar: T }) -data StructDef = - StructDef { - -- | The struct name - structDefName :: String, - -- | Generic type parameters - structDefGenerics :: [GenericParam], - -- | Optional where clause - structDefWhereClause :: (Maybe WhereClause), - -- | The struct body (named fields, tuple fields, or unit) - structDefBody :: StructBody, - -- | Derive macros to apply - structDefDerives :: [String], - -- | Whether the struct is public - structDefPublic :: Bool, - -- | Optional doc comment - structDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_StructDef = Core.Name "hydra.rust.syntax.StructDef" - -_StructDef_name = Core.Name "name" - -_StructDef_generics = Core.Name "generics" - -_StructDef_whereClause = Core.Name "whereClause" - -_StructDef_body = Core.Name "body" - -_StructDef_derives = Core.Name "derives" - -_StructDef_public = Core.Name "public" - -_StructDef_doc = Core.Name "doc" - --- | A struct literal expression -data StructExpr = - StructExpr { - -- | The struct path - structExprPath :: ExprPath, - -- | The field assignments - structExprFields :: [FieldValue], - -- | Optional base expression for struct update syntax - structExprRest :: (Maybe Expression)} - deriving (Eq, Ord, Read, Show) - -_StructExpr = Core.Name "hydra.rust.syntax.StructExpr" - -_StructExpr_path = Core.Name "path" - -_StructExpr_fields = Core.Name "fields" - -_StructExpr_rest = Core.Name "rest" - --- | A named field within a struct definition -data StructField = - StructField { - -- | The field name - structFieldName :: String, - -- | The field type - structFieldType :: Type, - -- | Whether the field is public - structFieldPublic :: Bool, - -- | Optional doc comment for the field - structFieldDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_StructField = Core.Name "hydra.rust.syntax.StructField" - -_StructField_name = Core.Name "name" - -_StructField_type = Core.Name "type" - -_StructField_public = Core.Name "public" - -_StructField_doc = Core.Name "doc" - --- | A struct pattern -data StructPattern = - StructPattern { - -- | The struct path - structPatternPath :: ExprPath, - -- | The field patterns - structPatternFields :: [FieldPattern], - -- | Whether the pattern has a rest (..) at the end - structPatternRest :: Bool} - deriving (Eq, Ord, Read, Show) - -_StructPattern = Core.Name "hydra.rust.syntax.StructPattern" - -_StructPattern_path = Core.Name "path" - -_StructPattern_fields = Core.Name "fields" - -_StructPattern_rest = Core.Name "rest" - --- | An associated constant within a trait -data TraitConst = - TraitConst { - -- | The constant name - traitConstName :: String, - -- | The constant type - traitConstType :: Type, - -- | Optional default value - traitConstDefault :: (Maybe Expression), - -- | Optional doc comment - traitConstDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_TraitConst = Core.Name "hydra.rust.syntax.TraitConst" - -_TraitConst_name = Core.Name "name" - -_TraitConst_type = Core.Name "type" - -_TraitConst_default = Core.Name "default" - -_TraitConst_doc = Core.Name "doc" - --- | A trait definition (e.g., trait Foo: Bar + Baz { ... }) -data TraitDef = - TraitDef { - -- | The trait name - traitDefName :: String, - -- | Generic type parameters - traitDefGenerics :: [GenericParam], - -- | Optional where clause - traitDefWhereClause :: (Maybe WhereClause), - -- | Supertraits - traitDefSuperTraits :: [TypeParamBound], - -- | The items within the trait - traitDefItems :: [TraitItem], - -- | Whether the trait is public - traitDefPublic :: Bool, - -- | Whether the trait is unsafe - traitDefUnsafe :: Bool, - -- | Optional doc comment - traitDefDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_TraitDef = Core.Name "hydra.rust.syntax.TraitDef" - -_TraitDef_name = Core.Name "name" - -_TraitDef_generics = Core.Name "generics" - -_TraitDef_whereClause = Core.Name "whereClause" - -_TraitDef_superTraits = Core.Name "superTraits" - -_TraitDef_items = Core.Name "items" - -_TraitDef_public = Core.Name "public" - -_TraitDef_unsafe = Core.Name "unsafe" - -_TraitDef_doc = Core.Name "doc" - --- | An item within a trait definition -data TraitItem = - -- | A method signature or default method - TraitItemMethod TraitMethod | - -- | An associated type - TraitItemType TraitType | - -- | An associated constant - TraitItemConst TraitConst - deriving (Eq, Ord, Read, Show) - -_TraitItem = Core.Name "hydra.rust.syntax.TraitItem" - -_TraitItem_method = Core.Name "method" - -_TraitItem_type = Core.Name "type" - -_TraitItem_const = Core.Name "const" - --- | A method signature or default method within a trait -data TraitMethod = - TraitMethod { - -- | The method name - traitMethodName :: String, - -- | Generic type parameters - traitMethodGenerics :: [GenericParam], - -- | Optional where clause - traitMethodWhereClause :: (Maybe WhereClause), - -- | The method parameters (including self) - traitMethodParams :: [MethodParam], - -- | The return type - traitMethodReturnType :: (Maybe Type), - -- | Optional default body - traitMethodDefaultBody :: (Maybe Block), - -- | Optional doc comment - traitMethodDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_TraitMethod = Core.Name "hydra.rust.syntax.TraitMethod" - -_TraitMethod_name = Core.Name "name" - -_TraitMethod_generics = Core.Name "generics" - -_TraitMethod_whereClause = Core.Name "whereClause" - -_TraitMethod_params = Core.Name "params" - -_TraitMethod_returnType = Core.Name "returnType" - -_TraitMethod_defaultBody = Core.Name "defaultBody" - -_TraitMethod_doc = Core.Name "doc" - --- | An associated type within a trait -data TraitType = - TraitType { - -- | The associated type name - traitTypeName :: String, - -- | Type parameter bounds - traitTypeBounds :: [TypeParamBound], - -- | Optional default type - traitTypeDefault :: (Maybe Type), - -- | Optional doc comment - traitTypeDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_TraitType = Core.Name "hydra.rust.syntax.TraitType" - -_TraitType_name = Core.Name "name" - -_TraitType_bounds = Core.Name "bounds" - -_TraitType_default = Core.Name "default" - -_TraitType_doc = Core.Name "doc" - --- | A positional field within a tuple struct -data TupleField = - TupleField { - -- | The field type - tupleFieldType :: Type, - -- | Whether the field is public - tupleFieldPublic :: Bool} - deriving (Eq, Ord, Read, Show) - -_TupleField = Core.Name "hydra.rust.syntax.TupleField" - -_TupleField_type = Core.Name "type" - -_TupleField_public = Core.Name "public" - --- | A tuple index expression -data TupleIndexExpr = - TupleIndexExpr { - -- | The tuple expression - tupleIndexExprTuple :: Expression, - -- | The index (0-based) - tupleIndexExprIndex :: Int} - deriving (Eq, Ord, Read, Show) - -_TupleIndexExpr = Core.Name "hydra.rust.syntax.TupleIndexExpr" - -_TupleIndexExpr_tuple = Core.Name "tuple" - -_TupleIndexExpr_index = Core.Name "index" - --- | A tuple struct pattern -data TupleStructPattern = - TupleStructPattern { - -- | The path to the tuple struct or variant - tupleStructPatternPath :: ExprPath, - -- | The element patterns - tupleStructPatternElements :: [Pattern]} - deriving (Eq, Ord, Read, Show) - -_TupleStructPattern = Core.Name "hydra.rust.syntax.TupleStructPattern" - -_TupleStructPattern_path = Core.Name "path" - -_TupleStructPattern_elements = Core.Name "elements" - --- | A Rust type expression -data Type = - -- | A path type, possibly with generic arguments - TypePath_ TypePath | - -- | A reference type - TypeReference ReferenceType | - -- | A slice type - TypeSlice Type | - -- | An array type with a fixed size - TypeArray ArrayType | - -- | A tuple type - TypeTuple [Type] | - -- | A function pointer type - TypeFnPointer FnPointerType | - -- | An impl Trait type - TypeImplTrait [TypeParamBound] | - -- | A dyn Trait type - TypeDynTrait [TypeParamBound] | - -- | The inferred type placeholder (_) - TypeInferred | - -- | The unit type (()) - TypeUnit | - -- | The never type (!) - TypeNever | - -- | A raw pointer type - TypeRawPointer RawPointerType | - -- | A macro invocation in type position - TypeMacro MacroInvocation - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.rust.syntax.Type" - -_Type_path = Core.Name "path" - -_Type_reference = Core.Name "reference" - -_Type_slice = Core.Name "slice" - -_Type_array = Core.Name "array" - -_Type_tuple = Core.Name "tuple" - -_Type_fnPointer = Core.Name "fnPointer" - -_Type_implTrait = Core.Name "implTrait" - -_Type_dynTrait = Core.Name "dynTrait" - -_Type_inferred = Core.Name "inferred" - -_Type_unit = Core.Name "unit" - -_Type_never = Core.Name "never" - -_Type_rawPointer = Core.Name "rawPointer" - -_Type_macro = Core.Name "macro" - --- | A type alias definition (e.g., type Foo = Bar;) -data TypeAlias = - TypeAlias { - -- | The alias name - typeAliasName :: String, - -- | Generic type parameters - typeAliasGenerics :: [GenericParam], - -- | The aliased type - typeAliasType :: Type, - -- | Whether the alias is public - typeAliasPublic :: Bool, - -- | Optional doc comment - typeAliasDoc :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_TypeAlias = Core.Name "hydra.rust.syntax.TypeAlias" - -_TypeAlias_name = Core.Name "name" - -_TypeAlias_generics = Core.Name "generics" - -_TypeAlias_type = Core.Name "type" - -_TypeAlias_public = Core.Name "public" - -_TypeAlias_doc = Core.Name "doc" - --- | A type ascription expression -data TypeAscriptionExpr = - TypeAscriptionExpr { - -- | The expression - typeAscriptionExprExpr :: Expression, - -- | The ascribed type - typeAscriptionExprType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeAscriptionExpr = Core.Name "hydra.rust.syntax.TypeAscriptionExpr" - -_TypeAscriptionExpr_expr = Core.Name "expr" - -_TypeAscriptionExpr_type = Core.Name "type" - --- | An associated type binding within generic arguments -data TypeBinding = - TypeBinding { - -- | The associated type name - typeBindingName :: String, - -- | The bound type - typeBindingType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeBinding = Core.Name "hydra.rust.syntax.TypeBinding" - -_TypeBinding_name = Core.Name "name" - -_TypeBinding_type = Core.Name "type" - --- | A bound on a type parameter -data TypeParamBound = - -- | A trait bound - TypeParamBoundTrait TypePath | - -- | A lifetime bound - TypeParamBoundLifetime Lifetime - deriving (Eq, Ord, Read, Show) - -_TypeParamBound = Core.Name "hydra.rust.syntax.TypeParamBound" - -_TypeParamBound_trait = Core.Name "trait" - -_TypeParamBound_lifetime = Core.Name "lifetime" - --- | A path-based type, possibly with generic arguments -data TypePath = - TypePath { - -- | Whether the path is absolute (starts with ::) - typePathGlobal :: Bool, - -- | The segments of the path - typePathSegments :: [PathSegment]} - deriving (Eq, Ord, Read, Show) - -_TypePath = Core.Name "hydra.rust.syntax.TypePath" - -_TypePath_global = Core.Name "global" - -_TypePath_segments = Core.Name "segments" - --- | A unary operation -data UnaryExpr = - UnaryExpr { - -- | The unary operator - unaryExprOp :: UnaryOp, - -- | The operand - unaryExprOperand :: Expression} - deriving (Eq, Ord, Read, Show) - -_UnaryExpr = Core.Name "hydra.rust.syntax.UnaryExpr" - -_UnaryExpr_op = Core.Name "op" - -_UnaryExpr_operand = Core.Name "operand" - --- | A unary operator -data UnaryOp = - UnaryOpNeg | - UnaryOpNot - deriving (Eq, Ord, Read, Show) - -_UnaryOp = Core.Name "hydra.rust.syntax.UnaryOp" - -_UnaryOp_neg = Core.Name "neg" - -_UnaryOp_not = Core.Name "not" - --- | A use declaration (e.g., use std::collections::BTreeMap;) -data UseDeclaration = - UseDeclaration { - -- | Whether the use is public (pub use) - useDeclarationPublic :: Bool, - -- | The use tree describing what is imported - useDeclarationTree :: UseTree} - deriving (Eq, Ord, Read, Show) - -_UseDeclaration = Core.Name "hydra.rust.syntax.UseDeclaration" - -_UseDeclaration_public = Core.Name "public" - -_UseDeclaration_tree = Core.Name "tree" - --- | A grouped import (e.g., std::collections::{BTreeMap, BTreeSet}) -data UseGroup = - UseGroup { - -- | The common prefix path segments - useGroupPrefix :: [String], - -- | The individual subtrees within the group - useGroupTrees :: [UseTree]} - deriving (Eq, Ord, Read, Show) - -_UseGroup = Core.Name "hydra.rust.syntax.UseGroup" - -_UseGroup_prefix = Core.Name "prefix" - -_UseGroup_trees = Core.Name "trees" - --- | A simple path import within a use tree -data UsePath = - UsePath { - -- | The path segments - usePathSegments :: [String]} - deriving (Eq, Ord, Read, Show) - -_UsePath = Core.Name "hydra.rust.syntax.UsePath" - -_UsePath_segments = Core.Name "segments" - --- | A renamed import (e.g., BTreeMap as Map) -data UseRename = - UseRename { - -- | The original path segments - useRenamePath :: [String], - -- | The alias name - useRenameAlias :: String} - deriving (Eq, Ord, Read, Show) - -_UseRename = Core.Name "hydra.rust.syntax.UseRename" - -_UseRename_path = Core.Name "path" - -_UseRename_alias = Core.Name "alias" - --- | A use tree, representing the structure of a use path -data UseTree = - -- | A simple path import - UseTreePath UsePath | - -- | A renamed import (e.g., BTreeMap as Map) - UseTreeRename UseRename | - -- | A glob import (e.g., std::collections::*) - UseTreeGlob [String] | - -- | A grouped import (e.g., {BTreeMap, BTreeSet}) - UseTreeGroup UseGroup - deriving (Eq, Ord, Read, Show) - -_UseTree = Core.Name "hydra.rust.syntax.UseTree" - -_UseTree_path = Core.Name "path" - -_UseTree_rename = Core.Name "rename" - -_UseTree_glob = Core.Name "glob" - -_UseTree_group = Core.Name "group" - --- | A visibility qualifier -data Visibility = - -- | Public (pub) - VisibilityPublic | - -- | Crate-visible (pub(crate)) - VisibilityCrate | - -- | Visible to a specific path (pub(in path)) - VisibilityRestricted [String] | - -- | Private (default) - VisibilityPrivate - deriving (Eq, Ord, Read, Show) - -_Visibility = Core.Name "hydra.rust.syntax.Visibility" - -_Visibility_public = Core.Name "public" - -_Visibility_crate = Core.Name "crate" - -_Visibility_restricted = Core.Name "restricted" - -_Visibility_private = Core.Name "private" - --- | A where clause (e.g., where T: Clone, U: Debug) -data WhereClause = - WhereClause { - -- | The predicates in the where clause - whereClausePredicates :: [WherePredicate]} - deriving (Eq, Ord, Read, Show) - -_WhereClause = Core.Name "hydra.rust.syntax.WhereClause" - -_WhereClause_predicates = Core.Name "predicates" - --- | A single predicate in a where clause -data WherePredicate = - WherePredicate { - -- | The type being constrained - wherePredicateType :: Type, - -- | The bounds on the type - wherePredicateBounds :: [TypeParamBound]} - deriving (Eq, Ord, Read, Show) - -_WherePredicate = Core.Name "hydra.rust.syntax.WherePredicate" - -_WherePredicate_type = Core.Name "type" - -_WherePredicate_bounds = Core.Name "bounds" - --- | A while expression, optionally with while let -data WhileExpr = - WhileExpr { - -- | Optional loop label - whileExprLabel :: (Maybe String), - -- | The condition - whileExprCondition :: IfCondition, - -- | The loop body - whileExprBody :: Block} - deriving (Eq, Ord, Read, Show) - -_WhileExpr = Core.Name "hydra.rust.syntax.WhileExpr" - -_WhileExpr_label = Core.Name "label" - -_WhileExpr_condition = Core.Name "condition" - -_WhileExpr_body = Core.Name "body" diff --git a/src/main/haskell/Hydra/Sql/Syntax.hs b/src/main/haskell/Hydra/Sql/Syntax.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sql/Syntax.hs +++ /dev/null @@ -1,1577 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A subset of ANSI SQL:2003, capturing selected productions of the BNF grammar provided at https://ronsavage.github.io/SQL/sql-2003-2.bnf.html, which is based on the Final Committee Draft (FCD) of ISO/IEC 9075-2:2003 - -module Hydra.Sql.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | An approximate (floating-point) numeric literal, such as 1.5E10 -newtype ApproximateNumericLiteral = - ApproximateNumericLiteral { - unApproximateNumericLiteral :: String} - deriving (Eq, Ord, Read, Show) - -_ApproximateNumericLiteral = Core.Name "hydra.sql.syntax.ApproximateNumericLiteral" - --- | An approximate numeric type: FLOAT, REAL, or DOUBLE PRECISION -data ApproximateNumericType = - ApproximateNumericTypeFloat (Maybe Precision) | - ApproximateNumericTypeReal | - ApproximateNumericTypeDouble - deriving (Eq, Ord, Read, Show) - -_ApproximateNumericType = Core.Name "hydra.sql.syntax.ApproximateNumericType" - -_ApproximateNumericType_float = Core.Name "float" - -_ApproximateNumericType_real = Core.Name "real" - -_ApproximateNumericType_double = Core.Name "double" - --- | A single element of an array value -newtype ArrayElement = - ArrayElement { - unArrayElement :: ValueExpression} - deriving (Eq, Ord, Read, Show) - -_ArrayElement = Core.Name "hydra.sql.syntax.ArrayElement" - --- | A non-empty, comma-separated list of array elements -data ArrayElementList = - ArrayElementList { - arrayElementListFirst :: ArrayElement, - arrayElementListRest :: [ArrayElement]} - deriving (Eq, Ord, Read, Show) - -_ArrayElementList = Core.Name "hydra.sql.syntax.ArrayElementList" - -_ArrayElementList_first = Core.Name "first" - -_ArrayElementList_rest = Core.Name "rest" - --- | A reference to an element of an array by index -newtype ArrayElementReference = - ArrayElementReference { - unArrayElementReference :: ()} - deriving (Eq, Ord, Read, Show) - -_ArrayElementReference = Core.Name "hydra.sql.syntax.ArrayElementReference" - --- | An ARRAY collection type -newtype ArrayType = - ArrayType { - unArrayType :: ()} - deriving (Eq, Ord, Read, Show) - -_ArrayType = Core.Name "hydra.sql.syntax.ArrayType" - --- | A constructor for an array value, either by enumeration or by query -data ArrayValueConstructor = - ArrayValueConstructorEnumeration ArrayValueConstructorByEnumeration | - ArrayValueConstructorQuery ArrayValueConstructorByQuery - deriving (Eq, Ord, Read, Show) - -_ArrayValueConstructor = Core.Name "hydra.sql.syntax.ArrayValueConstructor" - -_ArrayValueConstructor_enumeration = Core.Name "enumeration" - -_ArrayValueConstructor_query = Core.Name "query" - --- | An array value constructed by explicitly enumerating its elements -data ArrayValueConstructorByEnumeration = - ArrayValueConstructorByEnumeration { - arrayValueConstructorByEnumerationLeftBracketOrTrigraph :: LeftBracketOrTrigraph, - arrayValueConstructorByEnumerationArrayElementList :: ArrayElementList, - arrayValueConstructorByEnumerationRightBracketOrTrigraph :: RightBracketOrTrigraph} - deriving (Eq, Ord, Read, Show) - -_ArrayValueConstructorByEnumeration = Core.Name "hydra.sql.syntax.ArrayValueConstructorByEnumeration" - -_ArrayValueConstructorByEnumeration_LeftBracketOrTrigraph = Core.Name "LeftBracketOrTrigraph" - -_ArrayValueConstructorByEnumeration_ArrayElementList = Core.Name "ArrayElementList" - -_ArrayValueConstructorByEnumeration_RightBracketOrTrigraph = Core.Name "RightBracketOrTrigraph" - --- | An array value constructed from the result of a query -newtype ArrayValueConstructorByQuery = - ArrayValueConstructorByQuery { - unArrayValueConstructorByQuery :: ()} - deriving (Eq, Ord, Read, Show) - -_ArrayValueConstructorByQuery = Core.Name "hydra.sql.syntax.ArrayValueConstructorByQuery" - --- | An expression that evaluates to an array value -newtype ArrayValueExpression = - ArrayValueExpression { - unArrayValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_ArrayValueExpression = Core.Name "hydra.sql.syntax.ArrayValueExpression" - --- | A clause introducing a table's contents as the result of a subquery -newtype AsSubqueryClause = - AsSubqueryClause { - unAsSubqueryClause :: ()} - deriving (Eq, Ord, Read, Show) - -_AsSubqueryClause = Core.Name "hydra.sql.syntax.AsSubqueryClause" - --- | A reference to an attribute or method of a structured value -newtype AttributeOrMethodReference = - AttributeOrMethodReference { - unAttributeOrMethodReference :: ()} - deriving (Eq, Ord, Read, Show) - -_AttributeOrMethodReference = Core.Name "hydra.sql.syntax.AttributeOrMethodReference" - --- | A binary large object string type: BINARY LARGE OBJECT or BLOB -data BinaryLargeObjectStringType = - BinaryLargeObjectStringTypeBinary (Maybe LargeObjectLength) | - BinaryLargeObjectStringTypeBlob (Maybe LargeObjectLength) - deriving (Eq, Ord, Read, Show) - -_BinaryLargeObjectStringType = Core.Name "hydra.sql.syntax.BinaryLargeObjectStringType" - -_BinaryLargeObjectStringType_binary = Core.Name "binary" - -_BinaryLargeObjectStringType_blob = Core.Name "blob" - --- | A binary string literal, e.g. X'FF00' -newtype BinaryStringLiteral = - BinaryStringLiteral { - unBinaryStringLiteral :: ()} - deriving (Eq, Ord, Read, Show) - -_BinaryStringLiteral = Core.Name "hydra.sql.syntax.BinaryStringLiteral" - --- | A boolean test, optionally negated with NOT -data BooleanFactor = - BooleanFactor { - booleanFactorNOT :: (Maybe ()), - booleanFactorBooleanTest :: BooleanTest} - deriving (Eq, Ord, Read, Show) - -_BooleanFactor = Core.Name "hydra.sql.syntax.BooleanFactor" - -_BooleanFactor_NOT = Core.Name "NOT" - -_BooleanFactor_BooleanTest = Core.Name "BooleanTest" - --- | A boolean literal: TRUE, FALSE, or UNKNOWN -data BooleanLiteral = - BooleanLiteralTRUE | - BooleanLiteralFALSE | - BooleanLiteralUNKNOWN - deriving (Eq, Ord, Read, Show) - -_BooleanLiteral = Core.Name "hydra.sql.syntax.BooleanLiteral" - -_BooleanLiteral_TRUE = Core.Name "TRUE" - -_BooleanLiteral_FALSE = Core.Name "FALSE" - -_BooleanLiteral_UNKNOWN = Core.Name "UNKNOWN" - --- | An operand of a boolean predicate -newtype BooleanPredicand = - BooleanPredicand { - unBooleanPredicand :: ()} - deriving (Eq, Ord, Read, Show) - -_BooleanPredicand = Core.Name "hydra.sql.syntax.BooleanPredicand" - --- | A boolean primary expression: either a predicate or a boolean predicand -data BooleanPrimary = - BooleanPrimaryPredicate Predicate | - BooleanPrimaryPredicand BooleanPredicand - deriving (Eq, Ord, Read, Show) - -_BooleanPrimary = Core.Name "hydra.sql.syntax.BooleanPrimary" - -_BooleanPrimary_predicate = Core.Name "predicate" - -_BooleanPrimary_predicand = Core.Name "predicand" - --- | A boolean term: a factor, or a conjunction of terms with AND -data BooleanTerm = - BooleanTermFactor BooleanFactor | - BooleanTermConjunction BooleanTermAnd - deriving (Eq, Ord, Read, Show) - -_BooleanTerm = Core.Name "hydra.sql.syntax.BooleanTerm" - -_BooleanTerm_factor = Core.Name "factor" - -_BooleanTerm_conjunction = Core.Name "conjunction" - --- | A conjunction of two boolean terms joined by AND -data BooleanTermAnd = - BooleanTermAnd { - booleanTermAndLhs :: BooleanTerm, - booleanTermAndRhs :: BooleanFactor} - deriving (Eq, Ord, Read, Show) - -_BooleanTermAnd = Core.Name "hydra.sql.syntax.BooleanTermAnd" - -_BooleanTermAnd_lhs = Core.Name "lhs" - -_BooleanTermAnd_rhs = Core.Name "rhs" - --- | A boolean primary, optionally compared against a truth value with IS -data BooleanTest = - BooleanTest { - booleanTestBooleanPrimary :: BooleanPrimary, - booleanTestSequence :: (Maybe BooleanTestSequenceOption)} - deriving (Eq, Ord, Read, Show) - -_BooleanTest = Core.Name "hydra.sql.syntax.BooleanTest" - -_BooleanTest_BooleanPrimary = Core.Name "BooleanPrimary" - -_BooleanTest_Sequence = Core.Name "Sequence" - --- | The IS [NOT] truth-value suffix of a boolean test -data BooleanTestSequenceOption = - BooleanTestSequenceOption { - booleanTestSequenceOptionNOT :: (Maybe ()), - booleanTestSequenceOptionTruthValue :: TruthValue} - deriving (Eq, Ord, Read, Show) - -_BooleanTestSequenceOption = Core.Name "hydra.sql.syntax.BooleanTestSequenceOption" - -_BooleanTestSequenceOption_NOT = Core.Name "NOT" - -_BooleanTestSequenceOption_TruthValue = Core.Name "TruthValue" - --- | The BOOLEAN data type -newtype BooleanType = - BooleanType { - unBooleanType :: ()} - deriving (Eq, Ord, Read, Show) - -_BooleanType = Core.Name "hydra.sql.syntax.BooleanType" - --- | A boolean value expression: a term, or a disjunction of terms with OR -data BooleanValueExpression = - BooleanValueExpressionTerm BooleanTerm | - BooleanValueExpressionDisjunction BooleanValueExpressionOr - deriving (Eq, Ord, Read, Show) - -_BooleanValueExpression = Core.Name "hydra.sql.syntax.BooleanValueExpression" - -_BooleanValueExpression_term = Core.Name "term" - -_BooleanValueExpression_disjunction = Core.Name "disjunction" - --- | A disjunction of two boolean value expressions joined by OR -data BooleanValueExpressionOr = - BooleanValueExpressionOr { - booleanValueExpressionOrLhs :: BooleanValueExpression, - booleanValueExpressionOrRhs :: BooleanTerm} - deriving (Eq, Ord, Read, Show) - -_BooleanValueExpressionOr = Core.Name "hydra.sql.syntax.BooleanValueExpressionOr" - -_BooleanValueExpressionOr_lhs = Core.Name "lhs" - -_BooleanValueExpressionOr_rhs = Core.Name "rhs" - --- | A CASE expression, selecting a result from among several alternatives -newtype CaseExpression = - CaseExpression { - unCaseExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_CaseExpression = Core.Name "hydra.sql.syntax.CaseExpression" - --- | A CAST expression, converting a value to a specified data type -newtype CastSpecification = - CastSpecification { - unCastSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_CastSpecification = Core.Name "hydra.sql.syntax.CastSpecification" - --- | The name of a character set -newtype CharacterSetSpecification = - CharacterSetSpecification { - unCharacterSetSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_CharacterSetSpecification = Core.Name "hydra.sql.syntax.CharacterSetSpecification" - --- | A character string literal, e.g. 'hello' -newtype CharacterStringLiteral = - CharacterStringLiteral { - unCharacterStringLiteral :: String} - deriving (Eq, Ord, Read, Show) - -_CharacterStringLiteral = Core.Name "hydra.sql.syntax.CharacterStringLiteral" - --- | A character string type: CHARACTER, VARCHAR, or CHARACTER LARGE OBJECT -data CharacterStringType = - CharacterStringTypeCharacter (Maybe Length) | - CharacterStringTypeChar (Maybe Length) | - CharacterStringTypeCharacterVarying Length | - CharacterStringTypeCharVarying Length | - CharacterStringTypeVarchar Length | - CharacterStringTypeCharacterLargeObject (Maybe LargeObjectLength) | - CharacterStringTypeCharLargeObject (Maybe LargeObjectLength) | - CharacterStringTypeClob (Maybe LargeObjectLength) - deriving (Eq, Ord, Read, Show) - -_CharacterStringType = Core.Name "hydra.sql.syntax.CharacterStringType" - -_CharacterStringType_character = Core.Name "character" - -_CharacterStringType_char = Core.Name "char" - -_CharacterStringType_characterVarying = Core.Name "characterVarying" - -_CharacterStringType_charVarying = Core.Name "charVarying" - -_CharacterStringType_varchar = Core.Name "varchar" - -_CharacterStringType_characterLargeObject = Core.Name "characterLargeObject" - -_CharacterStringType_charLargeObject = Core.Name "charLargeObject" - -_CharacterStringType_clob = Core.Name "clob" - --- | A COLLATE clause specifying the collation to apply to a character value -newtype CollateClause = - CollateClause { - unCollateClause :: ()} - deriving (Eq, Ord, Read, Show) - -_CollateClause = Core.Name "hydra.sql.syntax.CollateClause" - --- | A collection type: ARRAY or MULTISET -data CollectionType = - CollectionTypeArray ArrayType | - CollectionTypeMultiset MultisetType - deriving (Eq, Ord, Read, Show) - -_CollectionType = Core.Name "hydra.sql.syntax.CollectionType" - -_CollectionType_array = Core.Name "array" - -_CollectionType_multiset = Core.Name "multiset" - --- | A constructor for a collection value: an array or multiset constructor -data CollectionValueConstructor = - CollectionValueConstructorArray ArrayValueConstructor | - CollectionValueConstructorMultiset MultisetValueConstructor - deriving (Eq, Ord, Read, Show) - -_CollectionValueConstructor = Core.Name "hydra.sql.syntax.CollectionValueConstructor" - -_CollectionValueConstructor_array = Core.Name "array" - -_CollectionValueConstructor_multiset = Core.Name "multiset" - --- | An expression that evaluates to a collection value -data CollectionValueExpression = - CollectionValueExpressionArray ArrayValueExpression | - CollectionValueExpressionMultiset MultisetValueExpression - deriving (Eq, Ord, Read, Show) - -_CollectionValueExpression = Core.Name "hydra.sql.syntax.CollectionValueExpression" - -_CollectionValueExpression_array = Core.Name "array" - -_CollectionValueExpression_multiset = Core.Name "multiset" - --- | A constraint attached to a single column definition -newtype ColumnConstraintDefinition = - ColumnConstraintDefinition { - unColumnConstraintDefinition :: ()} - deriving (Eq, Ord, Read, Show) - -_ColumnConstraintDefinition = Core.Name "hydra.sql.syntax.ColumnConstraintDefinition" - --- | The definition of a single column within a table definition -data ColumnDefinition = - ColumnDefinition { - columnDefinitionName :: ColumnName, - columnDefinitionTypeOrDomain :: (Maybe ColumnDefinitionTypeOrDomainOption), - columnDefinitionRefScope :: (Maybe ReferenceScopeCheck), - columnDefinitionDefaultOrIdentityOrGeneration :: (Maybe ColumnDefinitionDefaultOrIdentityOrGenerationOption), - columnDefinitionConstraints :: [ColumnConstraintDefinition], - columnDefinitionCollate :: (Maybe CollateClause)} - deriving (Eq, Ord, Read, Show) - -_ColumnDefinition = Core.Name "hydra.sql.syntax.ColumnDefinition" - -_ColumnDefinition_name = Core.Name "name" - -_ColumnDefinition_typeOrDomain = Core.Name "typeOrDomain" - -_ColumnDefinition_refScope = Core.Name "refScope" - -_ColumnDefinition_defaultOrIdentityOrGeneration = Core.Name "defaultOrIdentityOrGeneration" - -_ColumnDefinition_constraints = Core.Name "constraints" - -_ColumnDefinition_collate = Core.Name "collate" - --- | A column's default value, identity, or generation specification -data ColumnDefinitionDefaultOrIdentityOrGenerationOption = - ColumnDefinitionDefaultOrIdentityOrGenerationOptionDefaultClause DefaultClause | - ColumnDefinitionDefaultOrIdentityOrGenerationOptionIdentityColumnSpecification IdentityColumnSpecification | - ColumnDefinitionDefaultOrIdentityOrGenerationOptionGenerationClause GenerationClause - deriving (Eq, Ord, Read, Show) - -_ColumnDefinitionDefaultOrIdentityOrGenerationOption = - Core.Name "hydra.sql.syntax.ColumnDefinitionDefaultOrIdentityOrGenerationOption" - -_ColumnDefinitionDefaultOrIdentityOrGenerationOption_DefaultClause = Core.Name "DefaultClause" - -_ColumnDefinitionDefaultOrIdentityOrGenerationOption_IdentityColumnSpecification = - Core.Name "IdentityColumnSpecification" - -_ColumnDefinitionDefaultOrIdentityOrGenerationOption_GenerationClause = Core.Name "GenerationClause" - --- | A column's declared data type or domain -data ColumnDefinitionTypeOrDomainOption = - ColumnDefinitionTypeOrDomainOptionDataType DataType | - ColumnDefinitionTypeOrDomainOptionDomainName DomainName - deriving (Eq, Ord, Read, Show) - -_ColumnDefinitionTypeOrDomainOption = Core.Name "hydra.sql.syntax.ColumnDefinitionTypeOrDomainOption" - -_ColumnDefinitionTypeOrDomainOption_DataType = Core.Name "DataType" - -_ColumnDefinitionTypeOrDomainOption_DomainName = Core.Name "DomainName" - --- | The name of a table column -newtype ColumnName = - ColumnName { - unColumnName :: String} - deriving (Eq, Ord, Read, Show) - -_ColumnName = Core.Name "hydra.sql.syntax.ColumnName" - --- | A non-empty, comma-separated list of column names -data ColumnNameList = - ColumnNameList { - columnNameListFirst :: ColumnName, - columnNameListRest :: [ColumnName]} - deriving (Eq, Ord, Read, Show) - -_ColumnNameList = Core.Name "hydra.sql.syntax.ColumnNameList" - -_ColumnNameList_first = Core.Name "first" - -_ColumnNameList_rest = Core.Name "rest" - --- | The WITH OPTIONS clause of a column definition inherited via LIKE -newtype ColumnOptions = - ColumnOptions { - unColumnOptions :: ()} - deriving (Eq, Ord, Read, Show) - -_ColumnOptions = Core.Name "hydra.sql.syntax.ColumnOptions" - --- | A reference to a column, optionally qualified by a table or correlation name -newtype ColumnReference = - ColumnReference { - unColumnReference :: ()} - deriving (Eq, Ord, Read, Show) - -_ColumnReference = Core.Name "hydra.sql.syntax.ColumnReference" - --- | A value expression common to numeric, string, datetime, interval, user-defined, reference, and collection types -data CommonValueExpression = - CommonValueExpressionNumeric NumericValueExpression | - CommonValueExpressionString StringValueExpression | - CommonValueExpressionDatetime DatetimeValueExpression | - CommonValueExpressionInterval IntervalValueExpression | - CommonValueExpressionUserDefined UserDefinedTypeValueExpression | - CommonValueExpressionReference ReferenceValueExpression | - CommonValueExpressionCollection CollectionValueExpression - deriving (Eq, Ord, Read, Show) - -_CommonValueExpression = Core.Name "hydra.sql.syntax.CommonValueExpression" - -_CommonValueExpression_numeric = Core.Name "numeric" - -_CommonValueExpression_string = Core.Name "string" - -_CommonValueExpression_datetime = Core.Name "datetime" - -_CommonValueExpression_interval = Core.Name "interval" - -_CommonValueExpression_userDefined = Core.Name "userDefined" - -_CommonValueExpression_reference = Core.Name "reference" - -_CommonValueExpression_collection = Core.Name "collection" - --- | A row value constructor whose element types are inferred from context -newtype ContextuallyTypedRowValueConstructor = - ContextuallyTypedRowValueConstructor { - unContextuallyTypedRowValueConstructor :: ()} - deriving (Eq, Ord, Read, Show) - -_ContextuallyTypedRowValueConstructor = Core.Name "hydra.sql.syntax.ContextuallyTypedRowValueConstructor" - --- | A contextually typed row value expression: a special case or a constructor -data ContextuallyTypedRowValueExpression = - ContextuallyTypedRowValueExpressionSpecialCase RowValueSpecialCase | - ContextuallyTypedRowValueExpressionConstructor ContextuallyTypedRowValueConstructor - deriving (Eq, Ord, Read, Show) - -_ContextuallyTypedRowValueExpression = Core.Name "hydra.sql.syntax.ContextuallyTypedRowValueExpression" - -_ContextuallyTypedRowValueExpression_specialCase = Core.Name "specialCase" - -_ContextuallyTypedRowValueExpression_constructor = Core.Name "constructor" - --- | A non-empty, comma-separated list of contextually typed row value expressions -data ContextuallyTypedRowValueExpressionList = - ContextuallyTypedRowValueExpressionList { - contextuallyTypedRowValueExpressionListFirst :: ContextuallyTypedRowValueExpression, - contextuallyTypedRowValueExpressionListRest :: [ContextuallyTypedRowValueExpression]} - deriving (Eq, Ord, Read, Show) - -_ContextuallyTypedRowValueExpressionList = Core.Name "hydra.sql.syntax.ContextuallyTypedRowValueExpressionList" - -_ContextuallyTypedRowValueExpressionList_first = Core.Name "first" - -_ContextuallyTypedRowValueExpressionList_rest = Core.Name "rest" - --- | A table value constructor built from a list of contextually typed row values -newtype ContextuallyTypedTableValueConstructor = - ContextuallyTypedTableValueConstructor { - unContextuallyTypedTableValueConstructor :: ContextuallyTypedRowValueExpressionList} - deriving (Eq, Ord, Read, Show) - -_ContextuallyTypedTableValueConstructor = Core.Name "hydra.sql.syntax.ContextuallyTypedTableValueConstructor" - --- | A data type: predefined, row, named, reference, or collection -data DataType = - DataTypePredefined PredefinedType | - DataTypeRow RowType | - DataTypeNamed PathResolvedUserDefinedTypeName | - DataTypeReference ReferenceType | - DataTypeCollection CollectionType - deriving (Eq, Ord, Read, Show) - -_DataType = Core.Name "hydra.sql.syntax.DataType" - -_DataType_predefined = Core.Name "predefined" - -_DataType_row = Core.Name "row" - -_DataType_named = Core.Name "named" - -_DataType_reference = Core.Name "reference" - -_DataType_collection = Core.Name "collection" - --- | A DATE literal -newtype DateLiteral = - DateLiteral { - unDateLiteral :: DateString} - deriving (Eq, Ord, Read, Show) - -_DateLiteral = Core.Name "hydra.sql.syntax.DateLiteral" - --- | The string representation of a date literal, e.g. '2003-01-01' -newtype DateString = - DateString { - unDateString :: ()} - deriving (Eq, Ord, Read, Show) - -_DateString = Core.Name "hydra.sql.syntax.DateString" - --- | A datetime literal: a date, time, or timestamp literal -data DatetimeLiteral = - DatetimeLiteralDate DateLiteral | - DatetimeLiteralTime TimeLiteral | - DatetimeLiteralTimestamp TimestampLiteral - deriving (Eq, Ord, Read, Show) - -_DatetimeLiteral = Core.Name "hydra.sql.syntax.DatetimeLiteral" - -_DatetimeLiteral_date = Core.Name "date" - -_DatetimeLiteral_time = Core.Name "time" - -_DatetimeLiteral_timestamp = Core.Name "timestamp" - --- | A datetime type: DATE, TIME, or TIMESTAMP -newtype DatetimeType = - DatetimeType { - unDatetimeType :: ()} - deriving (Eq, Ord, Read, Show) - -_DatetimeType = Core.Name "hydra.sql.syntax.DatetimeType" - --- | An expression that evaluates to a datetime value -newtype DatetimeValueExpression = - DatetimeValueExpression { - unDatetimeValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_DatetimeValueExpression = Core.Name "hydra.sql.syntax.DatetimeValueExpression" - --- | A DEFAULT clause specifying a column's default value -newtype DefaultClause = - DefaultClause { - unDefaultClause :: ()} - deriving (Eq, Ord, Read, Show) - -_DefaultClause = Core.Name "hydra.sql.syntax.DefaultClause" - --- | The name of a user-defined domain -newtype DomainName = - DomainName { - unDomainName :: String} - deriving (Eq, Ord, Read, Show) - -_DomainName = Core.Name "hydra.sql.syntax.DomainName" - --- | An exact numeric literal, such as an integer or fixed-point decimal -newtype ExactNumericLiteral = - ExactNumericLiteral { - unExactNumericLiteral :: String} - deriving (Eq, Ord, Read, Show) - -_ExactNumericLiteral = Core.Name "hydra.sql.syntax.ExactNumericLiteral" - --- | An exact numeric type: NUMERIC, DECIMAL, DEC, SMALLINT, INTEGER, INT, or BIGINT -data ExactNumericType = - ExactNumericTypeNumeric (Maybe ExactNumericTypeNumericOption) | - ExactNumericTypeDecimal (Maybe ExactNumericTypeDecimalOption) | - ExactNumericTypeDec (Maybe ExactNumericTypeDecOption) | - ExactNumericTypeSmallint | - ExactNumericTypeInteger | - ExactNumericTypeInt | - ExactNumericTypeBigint - deriving (Eq, Ord, Read, Show) - -_ExactNumericType = Core.Name "hydra.sql.syntax.ExactNumericType" - -_ExactNumericType_numeric = Core.Name "numeric" - -_ExactNumericType_decimal = Core.Name "decimal" - -_ExactNumericType_dec = Core.Name "dec" - -_ExactNumericType_smallint = Core.Name "smallint" - -_ExactNumericType_integer = Core.Name "integer" - -_ExactNumericType_int = Core.Name "int" - -_ExactNumericType_bigint = Core.Name "bigint" - --- | The precision and optional scale of a DEC type -data ExactNumericTypeDecOption = - ExactNumericTypeDecOption { - exactNumericTypeDecOptionPrecision :: Precision, - exactNumericTypeDecOptionSequence :: (Maybe Scale)} - deriving (Eq, Ord, Read, Show) - -_ExactNumericTypeDecOption = Core.Name "hydra.sql.syntax.ExactNumericTypeDecOption" - -_ExactNumericTypeDecOption_Precision = Core.Name "Precision" - -_ExactNumericTypeDecOption_Sequence = Core.Name "Sequence" - --- | The precision and optional scale of a DECIMAL type -data ExactNumericTypeDecimalOption = - ExactNumericTypeDecimalOption { - exactNumericTypeDecimalOptionPrecision :: Precision, - exactNumericTypeDecimalOptionSequence :: (Maybe Scale)} - deriving (Eq, Ord, Read, Show) - -_ExactNumericTypeDecimalOption = Core.Name "hydra.sql.syntax.ExactNumericTypeDecimalOption" - -_ExactNumericTypeDecimalOption_Precision = Core.Name "Precision" - -_ExactNumericTypeDecimalOption_Sequence = Core.Name "Sequence" - --- | The precision and optional scale of a NUMERIC type -data ExactNumericTypeNumericOption = - ExactNumericTypeNumericOption { - exactNumericTypeNumericOptionPrecision :: Precision, - exactNumericTypeNumericOptionSequence :: (Maybe Scale)} - deriving (Eq, Ord, Read, Show) - -_ExactNumericTypeNumericOption = Core.Name "hydra.sql.syntax.ExactNumericTypeNumericOption" - -_ExactNumericTypeNumericOption_Precision = Core.Name "Precision" - -_ExactNumericTypeNumericOption_Sequence = Core.Name "Sequence" - --- | A reference to a field of a row or structured value -newtype FieldReference = - FieldReference { - unFieldReference :: ()} - deriving (Eq, Ord, Read, Show) - -_FieldReference = Core.Name "hydra.sql.syntax.FieldReference" - --- | An INSERT source specified by an explicit value constructor, with optional column list and override clause -data FromConstructor = - FromConstructor { - fromConstructorColumns :: (Maybe InsertColumnList), - fromConstructorOverride :: (Maybe OverrideClause), - fromConstructorValues :: ContextuallyTypedTableValueConstructor} - deriving (Eq, Ord, Read, Show) - -_FromConstructor = Core.Name "hydra.sql.syntax.FromConstructor" - -_FromConstructor_columns = Core.Name "columns" - -_FromConstructor_override = Core.Name "override" - -_FromConstructor_values = Core.Name "values" - --- | An INSERT source specified as DEFAULT VALUES -newtype FromDefault = - FromDefault { - unFromDefault :: ()} - deriving (Eq, Ord, Read, Show) - -_FromDefault = Core.Name "hydra.sql.syntax.FromDefault" - --- | An INSERT source specified as the result of a subquery -newtype FromSubquery = - FromSubquery { - unFromSubquery :: ()} - deriving (Eq, Ord, Read, Show) - -_FromSubquery = Core.Name "hydra.sql.syntax.FromSubquery" - --- | A general literal: a string, datetime, interval, or boolean literal -data GeneralLiteral = - GeneralLiteralString CharacterStringLiteral | - GeneralLiteralNationalString NationalCharacterStringLiteral | - GeneralLiteralUnicode UnicodeCharacterStringLiteral | - GeneralLiteralBinary BinaryStringLiteral | - GeneralLiteralDateTime DatetimeLiteral | - GeneralLiteralInterval IntervalLiteral | - GeneralLiteralBoolean BooleanLiteral - deriving (Eq, Ord, Read, Show) - -_GeneralLiteral = Core.Name "hydra.sql.syntax.GeneralLiteral" - -_GeneralLiteral_string = Core.Name "string" - -_GeneralLiteral_nationalString = Core.Name "nationalString" - -_GeneralLiteral_unicode = Core.Name "unicode" - -_GeneralLiteral_binary = Core.Name "binary" - -_GeneralLiteral_dateTime = Core.Name "dateTime" - -_GeneralLiteral_interval = Core.Name "interval" - -_GeneralLiteral_boolean = Core.Name "boolean" - --- | A general value specification, such as a parameter or dynamic value -newtype GeneralValueSpecification = - GeneralValueSpecification { - unGeneralValueSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_GeneralValueSpecification = Core.Name "hydra.sql.syntax.GeneralValueSpecification" - --- | A GENERATED ALWAYS AS clause for a computed column -newtype GenerationClause = - GenerationClause { - unGenerationClause :: ()} - deriving (Eq, Ord, Read, Show) - -_GenerationClause = Core.Name "hydra.sql.syntax.GenerationClause" - --- | The GLOBAL or LOCAL qualifier of a temporary table scope -data GlobalOrLocal = - GlobalOrLocalGlobal | - GlobalOrLocalLocal - deriving (Eq, Ord, Read, Show) - -_GlobalOrLocal = Core.Name "hydra.sql.syntax.GlobalOrLocal" - -_GlobalOrLocal_global = Core.Name "global" - -_GlobalOrLocal_local = Core.Name "local" - --- | A GENERATED ... AS IDENTITY column specification -newtype IdentityColumnSpecification = - IdentityColumnSpecification { - unIdentityColumnSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_IdentityColumnSpecification = Core.Name "hydra.sql.syntax.IdentityColumnSpecification" - --- | The parenthesized list of target column names in an INSERT statement -newtype InsertColumnList = - InsertColumnList { - unInsertColumnList :: ColumnNameList} - deriving (Eq, Ord, Read, Show) - -_InsertColumnList = Core.Name "hydra.sql.syntax.InsertColumnList" - --- | The column list and value source of an INSERT statement: a subquery, constructor, or default -data InsertColumnsAndSource = - InsertColumnsAndSourceSubquery FromSubquery | - InsertColumnsAndSourceConstructor FromConstructor | - InsertColumnsAndSourceDefault FromDefault - deriving (Eq, Ord, Read, Show) - -_InsertColumnsAndSource = Core.Name "hydra.sql.syntax.InsertColumnsAndSource" - -_InsertColumnsAndSource_subquery = Core.Name "subquery" - -_InsertColumnsAndSource_constructor = Core.Name "constructor" - -_InsertColumnsAndSource_default = Core.Name "default" - --- | An ANSI SQL INSERT statement -data InsertStatement = - InsertStatement { - insertStatementTarget :: InsertionTarget, - insertStatementColumnsAndSource :: InsertColumnsAndSource} - deriving (Eq, Ord, Read, Show) - -_InsertStatement = Core.Name "hydra.sql.syntax.InsertStatement" - -_InsertStatement_target = Core.Name "target" - -_InsertStatement_columnsAndSource = Core.Name "columnsAndSource" - --- | The table into which an INSERT statement inserts rows -newtype InsertionTarget = - InsertionTarget { - unInsertionTarget :: TableName} - deriving (Eq, Ord, Read, Show) - -_InsertionTarget = Core.Name "hydra.sql.syntax.InsertionTarget" - --- | An INTERVAL literal -newtype IntervalLiteral = - IntervalLiteral { - unIntervalLiteral :: ()} - deriving (Eq, Ord, Read, Show) - -_IntervalLiteral = Core.Name "hydra.sql.syntax.IntervalLiteral" - --- | The INTERVAL data type -newtype IntervalType = - IntervalType { - unIntervalType :: ()} - deriving (Eq, Ord, Read, Show) - -_IntervalType = Core.Name "hydra.sql.syntax.IntervalType" - --- | An expression that evaluates to an interval value -newtype IntervalValueExpression = - IntervalValueExpression { - unIntervalValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_IntervalValueExpression = Core.Name "hydra.sql.syntax.IntervalValueExpression" - --- | The length specification of a large object type, e.g. 1K, 1M, or 1G -newtype LargeObjectLength = - LargeObjectLength { - unLargeObjectLength :: ()} - deriving (Eq, Ord, Read, Show) - -_LargeObjectLength = Core.Name "hydra.sql.syntax.LargeObjectLength" - --- | A left square bracket, or its trigraph equivalent ??( -newtype LeftBracketOrTrigraph = - LeftBracketOrTrigraph { - unLeftBracketOrTrigraph :: String} - deriving (Eq, Ord, Read, Show) - -_LeftBracketOrTrigraph = Core.Name "hydra.sql.syntax.LeftBracketOrTrigraph" - --- | The length specification of a character or binary string type -newtype Length = - Length { - unLength :: UnsignedInteger} - deriving (Eq, Ord, Read, Show) - -_Length = Core.Name "hydra.sql.syntax.Length" - --- | A LIKE clause, copying column definitions from another table -newtype LikeClause = - LikeClause { - unLikeClause :: ()} - deriving (Eq, Ord, Read, Show) - -_LikeClause = Core.Name "hydra.sql.syntax.LikeClause" - --- | An invocation of a method on a structured value -newtype MethodInvocation = - MethodInvocation { - unMethodInvocation :: ()} - deriving (Eq, Ord, Read, Show) - -_MethodInvocation = Core.Name "hydra.sql.syntax.MethodInvocation" - --- | A reference to an element of a multiset by way of the ELEMENT function -newtype MultisetElementReference = - MultisetElementReference { - unMultisetElementReference :: ()} - deriving (Eq, Ord, Read, Show) - -_MultisetElementReference = Core.Name "hydra.sql.syntax.MultisetElementReference" - --- | A MULTISET collection type over a given element data type -newtype MultisetType = - MultisetType { - unMultisetType :: DataType} - deriving (Eq, Ord, Read, Show) - -_MultisetType = Core.Name "hydra.sql.syntax.MultisetType" - --- | A constructor for a multiset value -newtype MultisetValueConstructor = - MultisetValueConstructor { - unMultisetValueConstructor :: ()} - deriving (Eq, Ord, Read, Show) - -_MultisetValueConstructor = Core.Name "hydra.sql.syntax.MultisetValueConstructor" - --- | An expression that evaluates to a multiset value -newtype MultisetValueExpression = - MultisetValueExpression { - unMultisetValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_MultisetValueExpression = Core.Name "hydra.sql.syntax.MultisetValueExpression" - --- | A national character string literal, e.g. N'hello' -newtype NationalCharacterStringLiteral = - NationalCharacterStringLiteral { - unNationalCharacterStringLiteral :: ()} - deriving (Eq, Ord, Read, Show) - -_NationalCharacterStringLiteral = Core.Name "hydra.sql.syntax.NationalCharacterStringLiteral" - --- | A national character string type: NATIONAL CHARACTER or NATIONAL CHARACTER VARYING -newtype NationalCharacterStringType = - NationalCharacterStringType { - unNationalCharacterStringType :: ()} - deriving (Eq, Ord, Read, Show) - -_NationalCharacterStringType = Core.Name "hydra.sql.syntax.NationalCharacterStringType" - --- | A NEW invocation, constructing an instance of a structured type -newtype NewSpecification = - NewSpecification { - unNewSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_NewSpecification = Core.Name "hydra.sql.syntax.NewSpecification" - --- | A NEXT VALUE FOR expression, retrieving the next value of a sequence generator -newtype NextValueExpression = - NextValueExpression { - unNextValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_NextValueExpression = Core.Name "hydra.sql.syntax.NextValueExpression" - --- | A value expression primary that does not begin with a parenthesis -data NonparenthesizedValueExpressionPrimary = - NonparenthesizedValueExpressionPrimaryUnsigned UnsignedValueSpecification | - NonparenthesizedValueExpressionPrimaryColumn ColumnReference | - NonparenthesizedValueExpressionPrimarySetFunction SetFunctionSpecification | - NonparenthesizedValueExpressionPrimaryWindowFunction WindowFunction | - NonparenthesizedValueExpressionPrimaryScalarSubquery ScalarSubquery | - NonparenthesizedValueExpressionPrimaryCases CaseExpression | - NonparenthesizedValueExpressionPrimaryCast CastSpecification | - NonparenthesizedValueExpressionPrimaryField FieldReference | - NonparenthesizedValueExpressionPrimarySubtype SubtypeTreatment | - NonparenthesizedValueExpressionPrimaryMethod MethodInvocation | - NonparenthesizedValueExpressionPrimaryStaticMethod StaticMethodInvocation | - NonparenthesizedValueExpressionPrimaryNew NewSpecification | - NonparenthesizedValueExpressionPrimaryAttributeOrMethod AttributeOrMethodReference | - NonparenthesizedValueExpressionPrimaryReference ReferenceResolution | - NonparenthesizedValueExpressionPrimaryCollection CollectionValueConstructor | - NonparenthesizedValueExpressionPrimaryArrayElement ArrayElementReference | - NonparenthesizedValueExpressionPrimaryMultisetElement MultisetElementReference | - NonparenthesizedValueExpressionPrimaryRoutine RoutineInvocation | - NonparenthesizedValueExpressionPrimaryNext NextValueExpression - deriving (Eq, Ord, Read, Show) - -_NonparenthesizedValueExpressionPrimary = Core.Name "hydra.sql.syntax.NonparenthesizedValueExpressionPrimary" - -_NonparenthesizedValueExpressionPrimary_unsigned = Core.Name "unsigned" - -_NonparenthesizedValueExpressionPrimary_column = Core.Name "column" - -_NonparenthesizedValueExpressionPrimary_setFunction = Core.Name "setFunction" - -_NonparenthesizedValueExpressionPrimary_windowFunction = Core.Name "windowFunction" - -_NonparenthesizedValueExpressionPrimary_scalarSubquery = Core.Name "scalarSubquery" - -_NonparenthesizedValueExpressionPrimary_cases = Core.Name "cases" - -_NonparenthesizedValueExpressionPrimary_cast = Core.Name "cast" - -_NonparenthesizedValueExpressionPrimary_field = Core.Name "field" - -_NonparenthesizedValueExpressionPrimary_subtype = Core.Name "subtype" - -_NonparenthesizedValueExpressionPrimary_method = Core.Name "method" - -_NonparenthesizedValueExpressionPrimary_staticMethod = Core.Name "staticMethod" - -_NonparenthesizedValueExpressionPrimary_new = Core.Name "new" - -_NonparenthesizedValueExpressionPrimary_attributeOrMethod = Core.Name "attributeOrMethod" - -_NonparenthesizedValueExpressionPrimary_reference = Core.Name "reference" - -_NonparenthesizedValueExpressionPrimary_collection = Core.Name "collection" - -_NonparenthesizedValueExpressionPrimary_arrayElement = Core.Name "arrayElement" - -_NonparenthesizedValueExpressionPrimary_multisetElement = Core.Name "multisetElement" - -_NonparenthesizedValueExpressionPrimary_routine = Core.Name "routine" - -_NonparenthesizedValueExpressionPrimary_next = Core.Name "next" - --- | A numeric type: exact or approximate -data NumericType = - NumericTypeExact ExactNumericType | - NumericTypeApproximate ApproximateNumericType - deriving (Eq, Ord, Read, Show) - -_NumericType = Core.Name "hydra.sql.syntax.NumericType" - -_NumericType_exact = Core.Name "exact" - -_NumericType_approximate = Core.Name "approximate" - --- | An expression that evaluates to a numeric value -newtype NumericValueExpression = - NumericValueExpression { - unNumericValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_NumericValueExpression = Core.Name "hydra.sql.syntax.NumericValueExpression" - --- | An OVERRIDING USER VALUE or OVERRIDING SYSTEM VALUE clause of an INSERT statement -data OverrideClause = - OverrideClauseOVERRIDINGspUSERspVALUE | - OverrideClauseOVERRIDINGspSYSTEMspVALUE - deriving (Eq, Ord, Read, Show) - -_OverrideClause = Core.Name "hydra.sql.syntax.OverrideClause" - -_OverrideClause_OVERRIDINGspUSERspVALUE = Core.Name "OVERRIDINGspUSERspVALUE" - -_OverrideClause_OVERRIDINGspSYSTEMspVALUE = Core.Name "OVERRIDINGspSYSTEMspVALUE" - --- | A value expression enclosed in parentheses -newtype ParenthesizedValueExpression = - ParenthesizedValueExpression { - unParenthesizedValueExpression :: ValueExpression} - deriving (Eq, Ord, Read, Show) - -_ParenthesizedValueExpression = Core.Name "hydra.sql.syntax.ParenthesizedValueExpression" - --- | A user-defined type name, resolved against the current schema path -newtype PathResolvedUserDefinedTypeName = - PathResolvedUserDefinedTypeName { - unPathResolvedUserDefinedTypeName :: String} - deriving (Eq, Ord, Read, Show) - -_PathResolvedUserDefinedTypeName = Core.Name "hydra.sql.syntax.PathResolvedUserDefinedTypeName" - --- | The precision of a numeric type, as an unsigned integer -newtype Precision = - Precision { - unPrecision :: UnsignedInteger} - deriving (Eq, Ord, Read, Show) - -_Precision = Core.Name "hydra.sql.syntax.Precision" - --- | A predefined data type: string, numeric, boolean, datetime, or interval -data PredefinedType = - PredefinedTypeStringType PredefinedTypeString | - PredefinedTypeNationalStringType PredefinedTypeNationalString | - PredefinedTypeBlob BinaryLargeObjectStringType | - PredefinedTypeNumeric NumericType | - PredefinedTypeBoolean BooleanType | - PredefinedTypeDatetime DatetimeType | - PredefinedTypeInterval IntervalType - deriving (Eq, Ord, Read, Show) - -_PredefinedType = Core.Name "hydra.sql.syntax.PredefinedType" - -_PredefinedType_stringType = Core.Name "stringType" - -_PredefinedType_nationalStringType = Core.Name "nationalStringType" - -_PredefinedType_blob = Core.Name "blob" - -_PredefinedType_numeric = Core.Name "numeric" - -_PredefinedType_boolean = Core.Name "boolean" - -_PredefinedType_datetime = Core.Name "datetime" - -_PredefinedType_interval = Core.Name "interval" - --- | A national character string type together with an optional COLLATE clause -data PredefinedTypeNationalString = - PredefinedTypeNationalString { - predefinedTypeNationalStringType :: NationalCharacterStringType, - predefinedTypeNationalStringCollate :: (Maybe CollateClause)} - deriving (Eq, Ord, Read, Show) - -_PredefinedTypeNationalString = Core.Name "hydra.sql.syntax.PredefinedTypeNationalString" - -_PredefinedTypeNationalString_type = Core.Name "type" - -_PredefinedTypeNationalString_collate = Core.Name "collate" - --- | A character string type together with an optional character set and COLLATE clause -data PredefinedTypeString = - PredefinedTypeString { - predefinedTypeStringType :: CharacterStringType, - predefinedTypeStringCharacters :: (Maybe CharacterSetSpecification), - predefinedTypeStringCollate :: (Maybe CollateClause)} - deriving (Eq, Ord, Read, Show) - -_PredefinedTypeString = Core.Name "hydra.sql.syntax.PredefinedTypeString" - -_PredefinedTypeString_type = Core.Name "type" - -_PredefinedTypeString_characters = Core.Name "characters" - -_PredefinedTypeString_collate = Core.Name "collate" - --- | A predicate, evaluating to a boolean truth value -newtype Predicate = - Predicate { - unPredicate :: ()} - deriving (Eq, Ord, Read, Show) - -_Predicate = Core.Name "hydra.sql.syntax.Predicate" - --- | A query expression, such as a SELECT statement possibly combined with set operators -newtype QueryExpression = - QueryExpression { - unQueryExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_QueryExpression = Core.Name "hydra.sql.syntax.QueryExpression" - --- | The DEREF operator, resolving a reference to the value it targets -newtype ReferenceResolution = - ReferenceResolution { - unReferenceResolution :: ()} - deriving (Eq, Ord, Read, Show) - -_ReferenceResolution = Core.Name "hydra.sql.syntax.ReferenceResolution" - --- | A REFERENCES ARE [NOT] CHECKED clause on a reference-typed column -newtype ReferenceScopeCheck = - ReferenceScopeCheck { - unReferenceScopeCheck :: ()} - deriving (Eq, Ord, Read, Show) - -_ReferenceScopeCheck = Core.Name "hydra.sql.syntax.ReferenceScopeCheck" - --- | A REF reference type over a given referenced type -newtype ReferenceType = - ReferenceType { - unReferenceType :: ()} - deriving (Eq, Ord, Read, Show) - -_ReferenceType = Core.Name "hydra.sql.syntax.ReferenceType" - --- | An expression that evaluates to a reference value -newtype ReferenceValueExpression = - ReferenceValueExpression { - unReferenceValueExpression :: ValueExpressionPrimary} - deriving (Eq, Ord, Read, Show) - -_ReferenceValueExpression = Core.Name "hydra.sql.syntax.ReferenceValueExpression" - --- | A right square bracket, or its trigraph equivalent ??) -newtype RightBracketOrTrigraph = - RightBracketOrTrigraph { - unRightBracketOrTrigraph :: String} - deriving (Eq, Ord, Read, Show) - -_RightBracketOrTrigraph = Core.Name "hydra.sql.syntax.RightBracketOrTrigraph" - --- | An invocation of a user-defined SQL routine -newtype RoutineInvocation = - RoutineInvocation { - unRoutineInvocation :: ()} - deriving (Eq, Ord, Read, Show) - -_RoutineInvocation = Core.Name "hydra.sql.syntax.RoutineInvocation" - --- | A ROW type, defined by a list of field name and data type pairs -newtype RowType = - RowType { - unRowType :: ()} - deriving (Eq, Ord, Read, Show) - -_RowType = Core.Name "hydra.sql.syntax.RowType" - --- | An expression that evaluates to a row value -newtype RowValueExpression = - RowValueExpression { - unRowValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_RowValueExpression = Core.Name "hydra.sql.syntax.RowValueExpression" - --- | A row value expressed as a single nonparenthesized value expression -newtype RowValueSpecialCase = - RowValueSpecialCase { - unRowValueSpecialCase :: NonparenthesizedValueExpressionPrimary} - deriving (Eq, Ord, Read, Show) - -_RowValueSpecialCase = Core.Name "hydra.sql.syntax.RowValueSpecialCase" - --- | A subquery that returns exactly one row and one column -newtype ScalarSubquery = - ScalarSubquery { - unScalarSubquery :: Subquery} - deriving (Eq, Ord, Read, Show) - -_ScalarSubquery = Core.Name "hydra.sql.syntax.ScalarSubquery" - --- | The scale of a numeric type, as an unsigned integer -newtype Scale = - Scale { - unScale :: UnsignedInteger} - deriving (Eq, Ord, Read, Show) - -_Scale = Core.Name "hydra.sql.syntax.Scale" - --- | A REF IS clause identifying a table's self-referencing column -newtype SelfReferencingColumnSpecification = - SelfReferencingColumnSpecification { - unSelfReferencingColumnSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_SelfReferencingColumnSpecification = Core.Name "hydra.sql.syntax.SelfReferencingColumnSpecification" - --- | A set (aggregate) function invocation, such as COUNT or SUM -newtype SetFunctionSpecification = - SetFunctionSpecification { - unSetFunctionSpecification :: ()} - deriving (Eq, Ord, Read, Show) - -_SetFunctionSpecification = Core.Name "hydra.sql.syntax.SetFunctionSpecification" - --- | An invocation of a static method on a user-defined type -newtype StaticMethodInvocation = - StaticMethodInvocation { - unStaticMethodInvocation :: ()} - deriving (Eq, Ord, Read, Show) - -_StaticMethodInvocation = Core.Name "hydra.sql.syntax.StaticMethodInvocation" - --- | An expression that evaluates to a character, binary, or Unicode string value -newtype StringValueExpression = - StringValueExpression { - unStringValueExpression :: ()} - deriving (Eq, Ord, Read, Show) - -_StringValueExpression = Core.Name "hydra.sql.syntax.StringValueExpression" - --- | A parenthesized query expression used as an operand -newtype Subquery = - Subquery { - unSubquery :: QueryExpression} - deriving (Eq, Ord, Read, Show) - -_Subquery = Core.Name "hydra.sql.syntax.Subquery" - --- | An UNDER clause declaring a table as a subtable of a supertable -newtype SubtableClause = - SubtableClause { - unSubtableClause :: ()} - deriving (Eq, Ord, Read, Show) - -_SubtableClause = Core.Name "hydra.sql.syntax.SubtableClause" - --- | A TREAT AS expression, treating a value as an instance of a subtype -newtype SubtypeTreatment = - SubtypeTreatment { - unSubtypeTreatment :: ()} - deriving (Eq, Ord, Read, Show) - -_SubtypeTreatment = Core.Name "hydra.sql.syntax.SubtypeTreatment" - --- | The ON COMMIT action of a temporary table: PRESERVE ROWS or DELETE ROWS -data TableCommitAction = - TableCommitActionPreserve | - TableCommitActionDelete - deriving (Eq, Ord, Read, Show) - -_TableCommitAction = Core.Name "hydra.sql.syntax.TableCommitAction" - -_TableCommitAction_preserve = Core.Name "preserve" - -_TableCommitAction_delete = Core.Name "delete" - --- | A table-level constraint definition -newtype TableConstraintDefinition = - TableConstraintDefinition { - unTableConstraintDefinition :: ()} - deriving (Eq, Ord, Read, Show) - -_TableConstraintDefinition = Core.Name "hydra.sql.syntax.TableConstraintDefinition" - --- | The source of a table's contents: an element list, a supertable, or a query -data TableContentsSource = - TableContentsSourceList TableElementList | - TableContentsSourceSubtableOf TableContentsSourceSubtable | - TableContentsSourceSubquery AsSubqueryClause - deriving (Eq, Ord, Read, Show) - -_TableContentsSource = Core.Name "hydra.sql.syntax.TableContentsSource" - -_TableContentsSource_list = Core.Name "list" - -_TableContentsSource_subtableOf = Core.Name "subtableOf" - -_TableContentsSource_subquery = Core.Name "subquery" - --- | A table's contents defined as a subtable of a named user-defined type -data TableContentsSourceSubtable = - TableContentsSourceSubtable { - tableContentsSourceSubtableType :: PathResolvedUserDefinedTypeName, - tableContentsSourceSubtableSubtable :: (Maybe SubtableClause), - tableContentsSourceSubtableElements :: (Maybe TableElementList)} - deriving (Eq, Ord, Read, Show) - -_TableContentsSourceSubtable = Core.Name "hydra.sql.syntax.TableContentsSourceSubtable" - -_TableContentsSourceSubtable_type = Core.Name "type" - -_TableContentsSourceSubtable_subtable = Core.Name "subtable" - -_TableContentsSourceSubtable_elements = Core.Name "elements" - --- | An ANSI SQL CREATE TABLE statement -data TableDefinition = - TableDefinition { - tableDefinitionScope :: (Maybe TableScope), - tableDefinitionName :: TableName, - tableDefinitionSource :: TableContentsSource, - tableDefinitionCommitActions :: (Maybe TableCommitAction)} - deriving (Eq, Ord, Read, Show) - -_TableDefinition = Core.Name "hydra.sql.syntax.TableDefinition" - -_TableDefinition_scope = Core.Name "scope" - -_TableDefinition_name = Core.Name "name" - -_TableDefinition_source = Core.Name "source" - -_TableDefinition_commitActions = Core.Name "commitActions" - --- | An element of a table definition: a column, constraint, LIKE clause, or related option -data TableElement = - TableElementColumn ColumnDefinition | - TableElementTableConstraint TableConstraintDefinition | - TableElementLike LikeClause | - TableElementSelfReferencingColumn SelfReferencingColumnSpecification | - TableElementColumOptions ColumnOptions - deriving (Eq, Ord, Read, Show) - -_TableElement = Core.Name "hydra.sql.syntax.TableElement" - -_TableElement_column = Core.Name "column" - -_TableElement_tableConstraint = Core.Name "tableConstraint" - -_TableElement_like = Core.Name "like" - -_TableElement_selfReferencingColumn = Core.Name "selfReferencingColumn" - -_TableElement_columOptions = Core.Name "columOptions" - --- | A non-empty, comma-separated list of table elements -data TableElementList = - TableElementList { - tableElementListFirst :: TableElement, - tableElementListRest :: [TableElement]} - deriving (Eq, Ord, Read, Show) - -_TableElementList = Core.Name "hydra.sql.syntax.TableElementList" - -_TableElementList_first = Core.Name "first" - -_TableElementList_rest = Core.Name "rest" - --- | The name of a table -newtype TableName = - TableName { - unTableName :: String} - deriving (Eq, Ord, Read, Show) - -_TableName = Core.Name "hydra.sql.syntax.TableName" - --- | The GLOBAL or LOCAL TEMPORARY scope of a table definition -newtype TableScope = - TableScope { - unTableScope :: GlobalOrLocal} - deriving (Eq, Ord, Read, Show) - -_TableScope = Core.Name "hydra.sql.syntax.TableScope" - --- | A TIME literal -newtype TimeLiteral = - TimeLiteral { - unTimeLiteral :: TimeString} - deriving (Eq, Ord, Read, Show) - -_TimeLiteral = Core.Name "hydra.sql.syntax.TimeLiteral" - --- | The string representation of a time literal, e.g. '12:00:00' -newtype TimeString = - TimeString { - unTimeString :: ()} - deriving (Eq, Ord, Read, Show) - -_TimeString = Core.Name "hydra.sql.syntax.TimeString" - --- | A timestamp literal, combining a date and a time -newtype TimestampLiteral = - TimestampLiteral { - unTimestampLiteral :: ()} - deriving (Eq, Ord, Read, Show) - -_TimestampLiteral = Core.Name "hydra.sql.syntax.TimestampLiteral" - --- | A three-valued logic truth value: TRUE, FALSE, or UNKNOWN -data TruthValue = - TruthValueTRUE | - TruthValueFALSE | - TruthValueUNKNOWN - deriving (Eq, Ord, Read, Show) - -_TruthValue = Core.Name "hydra.sql.syntax.TruthValue" - -_TruthValue_TRUE = Core.Name "TRUE" - -_TruthValue_FALSE = Core.Name "FALSE" - -_TruthValue_UNKNOWN = Core.Name "UNKNOWN" - --- | A Unicode character string literal, e.g. U&'hello' -newtype UnicodeCharacterStringLiteral = - UnicodeCharacterStringLiteral { - unUnicodeCharacterStringLiteral :: ()} - deriving (Eq, Ord, Read, Show) - -_UnicodeCharacterStringLiteral = Core.Name "hydra.sql.syntax.UnicodeCharacterStringLiteral" - --- | An unsigned integer literal -newtype UnsignedInteger = - UnsignedInteger { - unUnsignedInteger :: String} - deriving (Eq, Ord, Read, Show) - -_UnsignedInteger = Core.Name "hydra.sql.syntax.UnsignedInteger" - --- | An unsigned literal: a numeric or general literal -data UnsignedLiteral = - UnsignedLiteralNumeric UnsignedNumericLiteral | - UnsignedLiteralGeneral GeneralLiteral - deriving (Eq, Ord, Read, Show) - -_UnsignedLiteral = Core.Name "hydra.sql.syntax.UnsignedLiteral" - -_UnsignedLiteral_numeric = Core.Name "numeric" - -_UnsignedLiteral_general = Core.Name "general" - --- | An unsigned numeric literal: exact or approximate -data UnsignedNumericLiteral = - UnsignedNumericLiteralExact ExactNumericLiteral | - UnsignedNumericLiteralApproximate ApproximateNumericLiteral - deriving (Eq, Ord, Read, Show) - -_UnsignedNumericLiteral = Core.Name "hydra.sql.syntax.UnsignedNumericLiteral" - -_UnsignedNumericLiteral_exact = Core.Name "exact" - -_UnsignedNumericLiteral_approximate = Core.Name "approximate" - --- | An unsigned value specification: a literal or a general value specification -data UnsignedValueSpecification = - UnsignedValueSpecificationLiteral UnsignedLiteral | - UnsignedValueSpecificationGeneral GeneralValueSpecification - deriving (Eq, Ord, Read, Show) - -_UnsignedValueSpecification = Core.Name "hydra.sql.syntax.UnsignedValueSpecification" - -_UnsignedValueSpecification_literal = Core.Name "literal" - -_UnsignedValueSpecification_general = Core.Name "general" - --- | An expression that evaluates to a value of a user-defined type -newtype UserDefinedTypeValueExpression = - UserDefinedTypeValueExpression { - unUserDefinedTypeValueExpression :: ValueExpressionPrimary} - deriving (Eq, Ord, Read, Show) - -_UserDefinedTypeValueExpression = Core.Name "hydra.sql.syntax.UserDefinedTypeValueExpression" - --- | A value expression: common, boolean, or row-valued -data ValueExpression = - ValueExpressionCommon CommonValueExpression | - ValueExpressionBoolean BooleanValueExpression | - ValueExpressionRow RowValueExpression - deriving (Eq, Ord, Read, Show) - -_ValueExpression = Core.Name "hydra.sql.syntax.ValueExpression" - -_ValueExpression_common = Core.Name "common" - -_ValueExpression_boolean = Core.Name "boolean" - -_ValueExpression_row = Core.Name "row" - --- | A value expression primary, optionally parenthesized -data ValueExpressionPrimary = - ValueExpressionPrimaryParens ParenthesizedValueExpression | - ValueExpressionPrimaryNoparens NonparenthesizedValueExpressionPrimary - deriving (Eq, Ord, Read, Show) - -_ValueExpressionPrimary = Core.Name "hydra.sql.syntax.ValueExpressionPrimary" - -_ValueExpressionPrimary_parens = Core.Name "parens" - -_ValueExpressionPrimary_noparens = Core.Name "noparens" - --- | A window function invocation, such as ROW_NUMBER() OVER (...) -newtype WindowFunction = - WindowFunction { - unWindowFunction :: ()} - deriving (Eq, Ord, Read, Show) - -_WindowFunction = Core.Name "hydra.sql.syntax.WindowFunction" diff --git a/src/main/haskell/Hydra/Stac/Items.hs b/src/main/haskell/Hydra/Stac/Items.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Stac/Items.hs +++ /dev/null @@ -1,191 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for SpatioTemporal Asset Catalog (STAC) Items. See https://github.com/radiantearth/stac-spec/blob/master/item-spec/item-spec.md - -module Hydra.Stac.Items where - -import qualified Hydra.Core as Core -import qualified Hydra.Geojson.Model as Model -import qualified Hydra.Iana.Linkrelations as Linkrelations -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | An Asset is an object that contains a URI to data associated with the Item that can be downloaded or streamed. It is allowed to add additional fields. -data Asset = - Asset { - -- | URI to the asset object. Relative and absolute URI are both allowed. - assetHref :: Uri, - -- | The displayed title for clients and users. - assetTitle :: (Maybe String), - -- | A description of the Asset providing additional details, such as how it was processed or created. CommonMark 0.29 syntax MAY be used for rich text representation. - assetDescription :: (Maybe String), - -- | Media type of the asset. See the common media types in the best practice doc for commonly used asset types. - assetType :: (Maybe MediaType), - -- | The semantic roles of the asset, similar to the use of rel in links. - assetRoles :: [Role]} - deriving (Eq, Ord, Read, Show) - -_Asset = Core.Name "hydra.stac.items.Asset" - -_Asset_href = Core.Name "href" - -_Asset_title = Core.Name "title" - -_Asset_description = Core.Name "description" - -_Asset_type = Core.Name "type" - -_Asset_roles = Core.Name "roles" - --- | This object describes a STAC Item. The fields id, type, bbox, geometry and properties are inherited from GeoJSON. -data Item = - Item { - itemFeature :: Model.Feature, - -- | The STAC version the Item implements - itemStacVersion :: StacVersion, - -- | A list of extensions the Item implements - itemStacExtensions :: [Url], - -- | List of link objects to resources and related URLs. A link with the rel set to self is strongly recommended. - itemLinks :: [Link], - -- | Dictionary of asset objects that can be downloaded, each with a unique key. - itemAssets :: (M.Map String Asset), - -- | The id of the STAC Collection this Item references to (see collection relation type). This field is required if such a relation type is present and is not allowed otherwise. This field provides an easy way for a user to search for any Items that belong in a specified Collection. Must be a non-empty string. - itemCollection :: (Maybe Model.Id)} - deriving (Eq, Ord, Read, Show) - -_Item = Core.Name "hydra.stac.items.Item" - -_Item_feature = Core.Name "feature" - -_Item_stacVersion = Core.Name "stacVersion" - -_Item_stacExtensions = Core.Name "stacExtensions" - -_Item_links = Core.Name "links" - -_Item_assets = Core.Name "assets" - -_Item_collection = Core.Name "collection" - --- | This object describes a relationship with another entity. Data providers are advised to be liberal with the links section, to describe things like the Catalog an Item is in, related Items, parent or child Items (modeled in different ways, like an 'acquisition' or derived data). It is allowed to add additional fields such as a title and type. -data Link = - Link { - -- | The actual link in the format of an URL. Relative and absolute links are both allowed. - linkHref :: Url, - -- | Relationship between the current document and the linked document. See chapter "Relation types" for more information. - linkRel :: RelationType, - -- | Media type of the referenced entity. - linkType :: (Maybe MediaType), - -- | A human readable title to be used in rendered displays of the link. - linkTitle :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Link = Core.Name "hydra.stac.items.Link" - -_Link_href = Core.Name "href" - -_Link_rel = Core.Name "rel" - -_Link_type = Core.Name "type" - -_Link_title = Core.Name "title" - --- | An IANA media type (MIME type) string identifying the format of an asset or linked resource -newtype MediaType = - MediaType { - unMediaType :: String} - deriving (Eq, Ord, Read, Show) - -_MediaType = Core.Name "hydra.stac.items.MediaType" - --- | STAC Items use a variety of rel types in the link object, to describe the exact nature of the link between this Item and the entity it is linking to. It is recommended to use the official IANA Link Relation Types where possible. The following table explains places where STAC use custom rel types are used with Items. This happens where there is not a clear official option, or where STAC uses an official type but adds additional meaning for the STAC context. -data RelationType = - RelationTypeIana Linkrelations.LinkRelationType | - RelationTypeStac StacRelationType | - RelationTypeOther String - deriving (Eq, Ord, Read, Show) - -_RelationType = Core.Name "hydra.stac.items.RelationType" - -_RelationType_iana = Core.Name "iana" - -_RelationType_stac = Core.Name "stac" - -_RelationType_other = Core.Name "other" - --- | The roles field is used to describe the purpose of each asset. It is recommended to include one for every asset, to give users a sense of why they might want to make use of the asset. There are some emerging standards that enable clients to take particular action when they encounter particular roles, listed below. But implementors are encouraged to come up with their own terms to describe the role. -data Role = - -- | An asset that represents a thumbnail of the Item, typically a true color image (for Items with assets in the visible wavelengths), lower-resolution (typically smaller 600x600 pixels), and typically a JPEG or PNG (suitable for display in a web browser). Multiple assets may have this purpose, but it recommended that the type and roles be unique tuples. For example, Sentinel-2 L2A provides thumbnail images in both JPEG and JPEG2000 formats, and would be distinguished by their media types. - RoleThumbnail | - -- | An asset that represents a possibly larger view than the thumbnail of the Item, for example, a true color composite of multi-band data. - RoleOverview | - -- | The data itself. This is a suggestion for a common role for data files to be used in case data providers don't come up with their own names and semantics. - RoleData | - -- | A metadata sidecar file describing the data in this Item, for example the Landsat-8 MTL file. - RoleMetadata | - RoleOther String - deriving (Eq, Ord, Read, Show) - -_Role = Core.Name "hydra.stac.items.Role" - -_Role_thumbnail = Core.Name "thumbnail" - -_Role_overview = Core.Name "overview" - -_Role_data = Core.Name "data" - -_Role_metadata = Core.Name "metadata" - -_Role_other = Core.Name "other" - --- | A STAC-specific link relation type used to describe relationships between STAC entities -data StacRelationType = - -- | STRONGLY RECOMMENDED. Absolute URL to the Item if it is available at a public URL. This is particularly useful when in a download package that includes metadata, so that the downstream user can know where the data has come from. - StacRelationTypeSelf | - -- | URL to the root STAC entity (Catalog or Collection). - StacRelationTypeRoot | - -- | URL to the parent STAC entity (Catalog or Collection). - StacRelationTypeParent | - -- | STRONGLY RECOMMENDED. URL to a Collection. Absolute URLs should be used whenever possible. The referenced Collection is STRONGLY RECOMMENDED to implement the same STAC version as the Item. A link with this rel type is required if the collection field in properties is present. - StacRelationTypeCollection | - -- | URL to a STAC Item that was used as input data in the creation of this Item. - StacRelationTypeDerivedFrom - deriving (Eq, Ord, Read, Show) - -_StacRelationType = Core.Name "hydra.stac.items.StacRelationType" - -_StacRelationType_self = Core.Name "self" - -_StacRelationType_root = Core.Name "root" - -_StacRelationType_parent = Core.Name "parent" - -_StacRelationType_collection = Core.Name "collection" - -_StacRelationType_derivedFrom = Core.Name "derivedFrom" - --- | The version of the STAC specification that an Item implements -newtype StacVersion = - StacVersion { - unStacVersion :: String} - deriving (Eq, Ord, Read, Show) - -_StacVersion = Core.Name "hydra.stac.items.StacVersion" - --- | A URI string, used for asset and other resource references -newtype Uri = - Uri { - unUri :: String} - deriving (Eq, Ord, Read, Show) - -_Uri = Core.Name "hydra.stac.items.Uri" - --- | A URL string, used for links to related entities -newtype Url = - Url { - unUrl :: String} - deriving (Eq, Ord, Read, Show) - -_Url = Core.Name "hydra.stac.items.Url" diff --git a/src/main/haskell/Hydra/Workflow.hs b/src/main/haskell/Hydra/Workflow.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Workflow.hs +++ /dev/null @@ -1,68 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for Hydra transformation workflows - -module Hydra.Workflow where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Packaging as Packaging -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | The specification of a Hydra schema, provided as a set of modules and a distinguished type -data HydraSchemaSpec = - HydraSchemaSpec { - -- | The modules to include in the schema graph - hydraSchemaSpecModules :: [Packaging.Module], - -- | The name of the top-level type; all data which passes through the workflow will be instances of this type - hydraSchemaSpecTypeName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_HydraSchemaSpec = Core.Name "hydra.workflow.HydraSchemaSpec" - -_HydraSchemaSpec_modules = Core.Name "modules" - -_HydraSchemaSpec_typeName = Core.Name "typeName" - --- | The specification of a schema at the source end of a workflow -data SchemaSpec = - -- | A native Hydra schema - SchemaSpecHydra HydraSchemaSpec | - -- | A schema provided as a file, available at the given file path - SchemaSpecFile String | - -- | A schema which will be provided within the workflow - SchemaSpecProvided - deriving (Eq, Ord, Read, Show) - -_SchemaSpec = Core.Name "hydra.workflow.SchemaSpec" - -_SchemaSpec_hydra = Core.Name "hydra" - -_SchemaSpec_file = Core.Name "file" - -_SchemaSpec_provided = Core.Name "provided" - --- | The specification of a workflow which takes a schema specification, reads data from a directory, and writes data to another directory -data TransformWorkflow = - TransformWorkflow { - -- | A descriptive name for the workflow - transformWorkflowName :: String, - -- | The schema specification - transformWorkflowSchemaSpec :: SchemaSpec, - -- | The source directory - transformWorkflowSrcDir :: String, - -- | The destination directory - transformWorkflowDestDir :: String} - deriving (Eq, Ord, Read, Show) - -_TransformWorkflow = Core.Name "hydra.workflow.TransformWorkflow" - -_TransformWorkflow_name = Core.Name "name" - -_TransformWorkflow_schemaSpec = Core.Name "schemaSpec" - -_TransformWorkflow_srcDir = Core.Name "srcDir" - -_TransformWorkflow_destDir = Core.Name "destDir" diff --git a/src/main/haskell/Hydra/Yaml/Coder.hs b/src/main/haskell/Hydra/Yaml/Coder.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Yaml/Coder.hs +++ /dev/null @@ -1,279 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | YAML encoding and decoding for Hydra terms - -module Hydra.Yaml.Coder where - -import qualified Hydra.Adapt as Adapt -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.Extract.Core as ExtractCore -import qualified Hydra.File as File -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as JsonModel -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as LibLiterals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Literals as Literals -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Print.Core as PrintCore -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import qualified Hydra.Yaml.Language as Language -import qualified Hydra.Yaml.Model as YamlModel -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Decode a YAML value to a record term -decodeRecord :: Core.Name -> [(Core.FieldType, (Coders.Coder Core.Term YamlModel.Node Errors.Error))] -> YamlModel.Node -> Either Errors.Error Core.Term -decodeRecord tname coders n = - - let decodeObjectBody = - \m -> - let decodeField = - \coder -> - let ft = Pairs.first coder - coder_ = Pairs.second coder - fname = Core.fieldTypeName ft - defaultValue = YamlModel.NodeScalar YamlModel.ScalarNull - yamlValue = Optionals.withDefault defaultValue (Maps.lookup (YamlModel.NodeScalar (YamlModel.ScalarStr (Core.unName fname))) m) - in (Eithers.bind (Coders.coderDecode coder_ yamlValue) (\v -> Right (Core.Field { - Core.fieldName = fname, - Core.fieldTerm = v}))) - in (Eithers.bind (Eithers.mapList decodeField coders) (\fields -> Right (Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = fields})))) - in case n of - YamlModel.NodeMapping v0 -> decodeObjectBody v0 - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected mapping")) - --- | Encode a record term to YAML -encodeRecord :: [(Core.FieldType, (Coders.Coder Core.Term YamlModel.Node Errors.Error))] -> Graph.Graph -> Core.Term -> Either Errors.Error YamlModel.Node -encodeRecord coders graph term = - - let stripped = Strip.deannotateTerm term - isMaybeNothing = - \ft -> \fvalue -> case (Core.fieldTypeType ft) of - Core.TypeOptional _ -> case fvalue of - Core.TermOptional v1 -> Optionals.isNone v1 - _ -> False - _ -> False - encodeField = - \coderAndField -> - let ftAndCoder = Pairs.first coderAndField - field = Pairs.second coderAndField - ft = Pairs.first ftAndCoder - coder_ = Pairs.second ftAndCoder - fname = Core.fieldName field - fvalue = Core.fieldTerm field - in (Logic.ifElse (isMaybeNothing ft fvalue) (Right Nothing) (Eithers.bind (Coders.coderEncode coder_ fvalue) (\encoded -> Right (Just (YamlModel.NodeScalar (YamlModel.ScalarStr (Core.unName fname)), encoded))))) - in (Eithers.bind (ExtractCore.termRecord graph stripped) (\record -> - let fields = Core.recordFields record - in (Eithers.bind (Eithers.mapList encodeField (Lists.zip coders fields)) (\maybeFields -> Right (YamlModel.NodeMapping (Maps.fromList (Optionals.givens maybeFields))))))) - --- | Create a YAML coder for literal types -literalYamlCoder :: Core.LiteralType -> Either t0 (Coders.Coder Core.Literal YamlModel.Scalar Errors.Error) -literalYamlCoder lt = - - let decodeBool = - \s -> case s of - YamlModel.ScalarBool v0 -> Right (Core.LiteralBoolean v0) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected boolean, found scalar"]))) - decodeDecimal = - \s -> case s of - YamlModel.ScalarDecimal v0 -> Right (Core.LiteralDecimal v0) - YamlModel.ScalarFloat v0 -> Right (Core.LiteralDecimal (LibLiterals.float64ToDecimal v0)) - YamlModel.ScalarInt v0 -> Right (Core.LiteralDecimal (LibLiterals.bigintToDecimal v0)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected decimal, found scalar"]))) - decodeFloat = - \s -> case s of - YamlModel.ScalarDecimal v0 -> Right (Core.LiteralFloat (Core.FloatValueFloat64 (LibLiterals.decimalToFloat64 v0))) - YamlModel.ScalarFloat v0 -> Right (Core.LiteralFloat (Core.FloatValueFloat64 v0)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected float, found scalar"]))) - decodeInteger = - \s -> case s of - YamlModel.ScalarInt v0 -> Right (Core.LiteralInteger (Core.IntegerValueBigint v0)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected integer, found scalar"]))) - decodeString = - \s -> case s of - YamlModel.ScalarStr v0 -> Right (Core.LiteralString v0) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected string, found scalar"]))) - encoded = - case lt of - Core.LiteralTypeBoolean -> Coders.Coder { - Coders.coderEncode = (\lit -> Eithers.bind (ExtractCore.booleanLiteral lit) (\b -> Right (YamlModel.ScalarBool b))), - Coders.coderDecode = decodeBool} - Core.LiteralTypeDecimal -> Coders.Coder { - Coders.coderEncode = (\lit -> Eithers.bind (ExtractCore.decimalLiteral lit) (\d -> Right (YamlModel.ScalarDecimal d))), - Coders.coderDecode = decodeDecimal} - Core.LiteralTypeFloat _ -> Coders.Coder { - Coders.coderEncode = (\lit -> Eithers.bind (ExtractCore.floatLiteral lit) (\f -> - let bf = - case f of - Core.FloatValueFloat32 v1 -> LibLiterals.float32ToFloat64 v1 - Core.FloatValueFloat64 v1 -> v1 - shown = LibLiterals.printFloat64 bf - in (Logic.ifElse (requiresYamlStringSentinel shown) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "YAML cannot represent float value: ", - shown])))) (Right (YamlModel.ScalarFloat bf))))), - Coders.coderDecode = decodeFloat} - Core.LiteralTypeInteger _ -> Coders.Coder { - Coders.coderEncode = (\lit -> Eithers.bind (ExtractCore.integerLiteral lit) (\i -> Eithers.bind (ExtractCore.bigintValue i) (\bi -> Right (YamlModel.ScalarInt bi)))), - Coders.coderDecode = decodeInteger} - Core.LiteralTypeString -> Coders.Coder { - Coders.coderEncode = (\lit -> Eithers.bind (ExtractCore.stringLiteral lit) (\s -> Right (YamlModel.ScalarStr s))), - Coders.coderDecode = decodeString} - in (Right encoded) - --- | Create a YAML coder for record types -recordCoder :: Core.Name -> [Core.FieldType] -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Core.Term YamlModel.Node Errors.Error) -recordCoder tname rt cx g = - - let getCoder = \f -> Eithers.bind (termCoder (Core.fieldTypeType f) cx g) (\coder -> Right (f, coder)) - in (Eithers.bind (Eithers.mapList getCoder rt) (\coders -> Right (Coders.Coder { - Coders.coderEncode = (\term -> encodeRecord coders g term), - Coders.coderDecode = (\val -> decodeRecord tname coders val)}))) - --- | True for IEEE sentinel strings that Hydra YAML cannot represent as a float scalar. -requiresYamlStringSentinel :: String -> Bool -requiresYamlStringSentinel s = - Logic.or (Equality.equal s "NaN") (Logic.or (Equality.equal s "Infinity") (Logic.or (Equality.equal s "-Infinity") (Equality.equal s "-0.0"))) - --- | Create a YAML coder for term types -termCoder :: Core.Type -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Core.Term YamlModel.Node Errors.Error) -termCoder typ cx g = - - let stripped = Strip.deannotateType typ - encodeLiteral = - \ac -> \term -> case term of - Core.TermLiteral v0 -> Eithers.bind (Coders.coderEncode ac v0) (\scalar -> Right (YamlModel.NodeScalar scalar)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected literal term, found: ", - (PrintCore.term term)]))) - encodeList = - \lc -> \term -> case term of - Core.TermList v0 -> Eithers.bind (Eithers.mapList (\el -> Coders.coderEncode lc el) v0) (\encodedEls -> Right (YamlModel.NodeSequence encodedEls)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected list term, found: ", - (PrintCore.term term)]))) - decodeList = - \lc -> \n -> case n of - YamlModel.NodeSequence v0 -> Eithers.bind (Eithers.mapList (\node -> Coders.coderDecode lc node) v0) (\decodedNodes -> Right (Core.TermList decodedNodes)) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected sequence")) - encodeMaybe = - \maybeElementCoder -> \maybeTerm -> - let strippedMaybeTerm = Strip.deannotateTerm maybeTerm - in case strippedMaybeTerm of - Core.TermOptional v0 -> Optionals.match v0 (Right (YamlModel.NodeScalar YamlModel.ScalarNull)) (\innerTerm -> Eithers.bind (Coders.coderEncode maybeElementCoder innerTerm) (\encodedInner -> Right encodedInner)) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected optional term, found: ", - (PrintCore.term maybeTerm)]))) - decodeMaybe = - \maybeElementCoder -> \yamlVal -> case yamlVal of - YamlModel.NodeScalar v0 -> case v0 of - YamlModel.ScalarNull -> Right (Core.TermOptional Nothing) - _ -> Eithers.bind (Coders.coderDecode maybeElementCoder yamlVal) (\decodedInner -> Right (Core.TermOptional (Just decodedInner))) - _ -> Eithers.bind (Coders.coderDecode maybeElementCoder yamlVal) (\decodedInner -> Right (Core.TermOptional (Just decodedInner))) - result = - case stripped of - Core.TypeLiteral v0 -> Eithers.bind (literalYamlCoder v0) (\ac -> Right (Coders.Coder { - Coders.coderEncode = (encodeLiteral ac), - Coders.coderDecode = (\n -> case n of - YamlModel.NodeScalar v1 -> Eithers.bind (Coders.coderDecode ac v1) (\lit -> Right (Core.TermLiteral lit)) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected scalar node")))})) - Core.TypeList v0 -> Eithers.bind (termCoder v0 cx g) (\lc -> Right (Coders.Coder { - Coders.coderEncode = (encodeList lc), - Coders.coderDecode = (decodeList lc)})) - Core.TypeMap v0 -> - let kt = Core.mapTypeKeys v0 - vt = Core.mapTypeValues v0 - in (Eithers.bind (termCoder kt cx g) (\kc -> Eithers.bind (termCoder vt cx g) (\vc -> - let encodeEntry = - \kv -> - let k = Pairs.first kv - v = Pairs.second kv - in (Eithers.bind (Coders.coderEncode kc k) (\encodedK -> Eithers.bind (Coders.coderEncode vc v) (\encodedV -> Right (encodedK, encodedV)))) - decodeEntry = - \kv -> - let k = Pairs.first kv - v = Pairs.second kv - in (Eithers.bind (Coders.coderDecode kc k) (\decodedK -> Eithers.bind (Coders.coderDecode vc v) (\decodedV -> Right (decodedK, decodedV)))) - in (Right (Coders.Coder { - Coders.coderEncode = (\term -> case term of - Core.TermMap v1 -> Eithers.bind (Eithers.mapList (\entry -> encodeEntry entry) (Maps.toList v1)) (\entries -> Right (YamlModel.NodeMapping (Maps.fromList entries))) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected map term, found: ", - (PrintCore.term term)])))), - Coders.coderDecode = (\n -> case n of - YamlModel.NodeMapping v1 -> Eithers.bind (Eithers.mapList (\entry -> decodeEntry entry) (Maps.toList v1)) (\entries -> Right (Core.TermMap (Maps.fromList entries))) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected mapping")))}))))) - Core.TypeOptional v0 -> Eithers.bind (termCoder v0 cx g) (\maybeElementCoder -> Right (Coders.Coder { - Coders.coderEncode = (encodeMaybe maybeElementCoder), - Coders.coderDecode = (decodeMaybe maybeElementCoder)})) - Core.TypeRecord v0 -> recordCoder (Core.Name "yaml") v0 cx g - Core.TypeUnit -> Right unitCoder - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "unsupported type in YAML: ", - (PrintCore.type_ typ)]))) - in result - --- | YAML coder for unit values -unitCoder :: Coders.Coder Core.Term YamlModel.Node Errors.Error -unitCoder = - Coders.Coder { - Coders.coderEncode = encodeUnit, - Coders.coderDecode = decodeUnit} - where - encodeUnit = - \term -> case (Strip.deannotateTerm term) of - Core.TermUnit -> Right (YamlModel.NodeScalar YamlModel.ScalarNull) - _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ - "expected unit, found: ", - (PrintCore.term term)]))) - decodeUnit = - \n -> case n of - YamlModel.NodeScalar v0 -> case v0 of - YamlModel.ScalarNull -> Right Core.TermUnit - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected null scalar")) - _ -> Left (Errors.ErrorOther (Errors.OtherError "expected null")) - --- | Create a YAML coder for a given type -yamlCoder :: Core.Type -> t0 -> Graph.Graph -> Either Errors.Error (Coders.Coder Core.Term YamlModel.Node Errors.Error) -yamlCoder typ cx g = - - let mkTermCoder = \t -> termCoder t cx g - in (Eithers.bind (Adapt.simpleLanguageAdapter Language.yamlLanguage cx g typ) (\adapter -> Eithers.bind (mkTermCoder (Coders.adapterTarget adapter)) (\coder -> Right (Adapt.composeCoders (Coders.adapterCoder adapter) coder)))) diff --git a/src/main/haskell/Hydra/Yaml/Language.hs b/src/main/haskell/Hydra/Yaml/Language.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Yaml/Language.hs +++ /dev/null @@ -1,103 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for YAML - -module Hydra.Yaml.Language 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.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.Strip as Strip -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Language constraints for YAML -yamlLanguage :: Coders.Language -yamlLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.yaml"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}, - Coders.languageSupportedFeatures = (Sets.fromList [ - Coders.LanguageFeaturePartialApplication, - Coders.LanguageFeatureNestedCaseStatements, - Coders.LanguageFeatureNestedPolymorphicLetBindings]), - Coders.languageCaseConventions = Coders.CaseConventions { - Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, - Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, - Coders.caseConventionsEnumValue = Util.CaseConventionPascal, - Coders.caseConventionsField = Util.CaseConventionCamel, - Coders.caseConventionsFile = Util.CaseConventionLowerSnake, - Coders.caseConventionsModule = Util.CaseConventionLowerSnake, - Coders.caseConventionsTerm = Util.CaseConventionCamel, - Coders.caseConventionsTermVariable = Util.CaseConventionCamel, - Coders.caseConventionsType = Util.CaseConventionPascal, - Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, - Coders.languageDefaultFileExtension = (File.FileExtension "yaml")} - where - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = Sets.fromList [ - Core.FloatTypeFloat64] - integerTypes = Sets.fromList [ - Core.IntegerTypeBigint] - termVariants = - Sets.fromList [ - Variants.TermVariantLiteral, - Variants.TermVariantList, - Variants.TermVariantMap, - Variants.TermVariantOptional, - Variants.TermVariantRecord, - Variants.TermVariantUnit] - typeVariants = - Sets.fromList [ - Variants.TypeVariantLiteral, - Variants.TypeVariantList, - Variants.TypeVariantMap, - Variants.TypeVariantOptional, - Variants.TypeVariantRecord, - Variants.TypeVariantUnit, - Variants.TypeVariantVoid] - typePredicate = - \typ -> case (Strip.deannotateType typ) of - Core.TypeOptional v0 -> case v0 of - Core.TypeOptional _ -> False - _ -> True - _ -> True diff --git a/src/main/haskell/Hydra/Yaml/Serde.hs b/src/main/haskell/Hydra/Yaml/Serde.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Yaml/Serde.hs +++ /dev/null @@ -1,264 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Native YAML serialization: YAML Node to String - -module Hydra.Yaml.Serde 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.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as JsonModel -import qualified Hydra.Overlay.Haskell.Lib.Chars as Chars -import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -import qualified Hydra.System as System -import qualified Hydra.Tabular as Tabular -import qualified Hydra.Testing as Testing -import qualified Hydra.Time as Time -import qualified Hydra.Topology as Topology -import qualified Hydra.Typed as Typed -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants -import qualified Hydra.Yaml.Model as YamlModel -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Escape single quotes by doubling them -escapeSingleQuotes :: String -> String -escapeSingleQuotes s = - - let squote = 39 - in (Strings.fromList (Lists.bind (Strings.toList s) (\c -> Logic.ifElse (Equality.equal c squote) [ - squote, - squote] [ - c]))) - --- | Check if a string has leading or trailing whitespace -hasLeadingTrailingSpace :: String -> Bool -hasLeadingTrailingSpace s = - - let chars = Strings.toList s - in (Logic.or (Optionals.withDefault False (Optionals.map (\c -> Chars.isSpace c) (Lists.head chars))) (Optionals.withDefault False (Optionals.map (\c -> Chars.isSpace c) (Lists.last chars)))) - --- | Serialize a YAML node to a string -hydraYamlToString :: YamlModel.Node -> String -hydraYamlToString node = writeNode node - --- | Indent all lines of a string by 2 spaces -indentString :: String -> String -indentString s = - Strings.concat (Lists.map (\line -> Logic.ifElse (Strings.isEmpty line) "" (Strings.concat [ - " ", - line, - "\n"])) (Formatting.lines s)) - --- | Check if character codes represent a decimal number -isDecimalString :: [Int] -> Bool -isDecimalString chars = - - let dotCode = 46 - parts = Lists.span (\c -> Logic.not (Equality.equal c dotCode)) chars - before = Pairs.first parts - afterWithDot = Pairs.second parts - in (Logic.ifElse (Lists.isEmpty before) False (Logic.ifElse (Lists.isEmpty afterWithDot) False ( - let after = Lists.drop 1 afterWithDot - in (Logic.ifElse (Lists.isEmpty after) False ( - let isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) - in (Logic.and (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) before)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) after)))))))) - --- | Check if a string looks like a number -looksLikeNumber :: String -> Bool -looksLikeNumber s = - - let chars = Strings.toList s - in (Optionals.withDefault False (Optionals.map (\p -> - let firstCh = Pairs.first p - tailCh = Pairs.second p - rest = Logic.ifElse (Equality.equal firstCh 45) tailCh chars - isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) - allDigits = Logic.and (Logic.not (Lists.isEmpty rest)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) rest)) - in (Logic.ifElse allDigits True (isDecimalString rest))) (Lists.uncons chars))) - --- | Check if a string needs quoting in YAML -needsQuoting :: String -> Bool -needsQuoting s = - Logic.ifElse (Strings.isEmpty s) True (Logic.ifElse (Lists.member s yamlReservedWords) True (Logic.ifElse (looksLikeNumber s) True ( - let chars = Strings.toList s - specials = Strings.toList yamlSpecialChars - hasSpecial = Logic.not (Lists.isEmpty (Lists.filter (\c -> Lists.member c specials) chars)) - in (Logic.ifElse hasSpecial True (hasLeadingTrailingSpace s))))) - --- | Write a mapping entry in block style -writeMappingEntry :: (YamlModel.Node, YamlModel.Node) -> String -writeMappingEntry entry = - - let key = Pairs.first entry - value = Pairs.second entry - in case value of - YamlModel.NodeScalar v0 -> Strings.concat [ - writeNodeInline key, - ": ", - (writeScalar v0), - "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ - writeNodeInline key, - ": []\n"]) (Strings.concat [ - writeNodeInline key, - ":\n", - (indentString (writeNode value))]) - YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) (Strings.concat [ - writeNodeInline key, - ": {}\n"]) (Strings.concat [ - writeNodeInline key, - ":\n", - (indentString (writeNode value))]) - --- | Write a mapping entry for the first item of a sequence element -writeMappingEntryInline :: (YamlModel.Node, YamlModel.Node) -> String -writeMappingEntryInline entry = - - let key = Pairs.first entry - value = Pairs.second entry - in case value of - YamlModel.NodeScalar v0 -> Strings.concat [ - writeNodeInline key, - ": ", - (writeScalar v0), - "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ - writeNodeInline key, - ": []\n"]) (Strings.concat [ - writeNodeInline key, - ":\n", - (indentString (writeNode value))]) - YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) (Strings.concat [ - writeNodeInline key, - ": {}\n"]) (Strings.concat [ - writeNodeInline key, - ":\n", - (indentString (writeNode value))]) - --- | Write a YAML node as a top-level value in block style -writeNode :: YamlModel.Node -> String -writeNode node = - case node of - YamlModel.NodeScalar v0 -> Strings.concat2 (writeScalar v0) "\n" - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "[]\n" (Strings.concat (Lists.map (\item -> writeSequenceItem item) v0)) - YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "{}\n" (Strings.concat (Lists.map (\e -> writeMappingEntry e) (Maps.toList v0))) - --- | Write a node inline (for use as a mapping key) -writeNodeInline :: YamlModel.Node -> String -writeNodeInline node = - case node of - YamlModel.NodeScalar v0 -> writeScalar v0 - YamlModel.NodeSequence v0 -> Strings.concat [ - "[", - (Strings.join ", " (Lists.map (\item -> writeNodeInline item) v0)), - "]"] - YamlModel.NodeMapping v0 -> - let writeFlowEntry = - \e -> Strings.concat [ - writeNodeInline (Pairs.first e), - ": ", - (writeNodeInline (Pairs.second e))] - in (Strings.concat [ - "{", - (Strings.join ", " (Lists.map writeFlowEntry (Maps.toList v0))), - "}"]) - --- | Write a scalar value -writeScalar :: YamlModel.Scalar -> String -writeScalar s = - case s of - YamlModel.ScalarBool v0 -> Logic.ifElse v0 "true" "false" - YamlModel.ScalarDecimal v0 -> Literals.printDecimal v0 - YamlModel.ScalarFloat v0 -> Literals.printFloat64 v0 - YamlModel.ScalarInt v0 -> Literals.printBigint v0 - YamlModel.ScalarNull -> "null" - YamlModel.ScalarStr v0 -> writeString v0 - --- | Write a sequence item in block style -writeSequenceItem :: YamlModel.Node -> String -writeSequenceItem node = - case node of - YamlModel.NodeScalar v0 -> Strings.concat [ - "- ", - (writeScalar v0), - "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "- []\n" (Strings.concat2 "-\n" (indentString (writeNode node))) - YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "- {}\n" ( - let entries = Maps.toList v0 - in (Optionals.withDefault "" (Optionals.map (\p -> - let firstEntry = Pairs.first p - restEntries = Pairs.second p - firstStr = writeMappingEntryInline firstEntry - restStr = Strings.concat (Lists.map (\e -> writeMappingEntry e) restEntries) - in (Strings.concat [ - "- ", - firstStr, - (indentString restStr)])) (Lists.uncons entries)))) - --- | Write a string value, quoting if necessary -writeString :: String -> String -writeString s = - Logic.ifElse (needsQuoting s) (Strings.concat [ - "'", - (escapeSingleQuotes s), - "'"]) s - --- | YAML reserved words that need quoting -yamlReservedWords :: [String] -yamlReservedWords = - [ - "true", - "false", - "null", - "~", - "yes", - "no", - "on", - "off", - "True", - "False", - "Null", - "Yes", - "No", - "On", - "Off", - "TRUE", - "FALSE", - "NULL", - "YES", - "NO", - "ON", - "OFF"] - --- | YAML special characters that trigger quoting -yamlSpecialChars :: String -yamlSpecialChars = ": {}[]#,&*!|>'\"%@`"