hydra-ext 0.17.0 → 0.17.4

raw patch · 58 files changed

+17789/−9928 lines, 58 filesdep ~hydra-kerneldep ~hydra-rdfPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-kernel, hydra-rdf

API changes (from Hackage documentation)

Files

• CHANGELOG.md +234/−0
• hydra-ext.cabal +4/−4
• src/main/haskell/Hydra/Atlas.hs +94/−16
• src/main/haskell/Hydra/Avro/Coder.hs +82/−36
• src/main/haskell/Hydra/Avro/Encoder.hs +82/−48
• src/main/haskell/Hydra/Avro/Environment.hs +47/−24
• src/main/haskell/Hydra/Avro/Language.hs +27/−1
• src/main/haskell/Hydra/Avro/Schema.hs +77/−0
• src/main/haskell/Hydra/Avro/SchemaJson.hs +194/−84
• src/main/haskell/Hydra/Avro/Testing.hs +224/−140
• src/main/haskell/Hydra/Azure/Dtld.hs +338/−135
• src/main/haskell/Hydra/Cpp/Coder.hs +149/−13
• src/main/haskell/Hydra/Cpp/Environment.hs +6/−0
• src/main/haskell/Hydra/Cpp/Language.hs +28/−1
• src/main/haskell/Hydra/Cpp/Names.hs +34/−7
• src/main/haskell/Hydra/Cpp/Serde.hs +151/−21
• src/main/haskell/Hydra/Cpp/Syntax.hs +2031/−1252
• src/main/haskell/Hydra/Cpp/Utils.hs +48/−0
• src/main/haskell/Hydra/Csharp/Language.hs +28/−1
• src/main/haskell/Hydra/Csharp/Syntax.hs +5295/−3275
• src/main/haskell/Hydra/Datalog/Syntax.hs +135/−66
• src/main/haskell/Hydra/Delta/Parquet.hs +44/−0
• src/main/haskell/Hydra/Geojson/Model.hs +80/−9
• src/main/haskell/Hydra/Graphql/Coder.hs +47/−12
• src/main/haskell/Hydra/Graphql/Language.hs +28/−1
• src/main/haskell/Hydra/Graphql/Serde.hs +27/−1
• src/main/haskell/Hydra/Graphql/Syntax.hs +1395/−864
• src/main/haskell/Hydra/Iana/Linkrelations.hs +125/−0
• src/main/haskell/Hydra/Json/Schema.hs +0/−174
• src/main/haskell/Hydra/Json/Schema/Coder.hs +100/−73
• src/main/haskell/Hydra/Json/Schema/Language.hs +27/−1
• src/main/haskell/Hydra/Json/Schema/Model.hs +279/−0
• src/main/haskell/Hydra/Json/Schema/Serde.hs +261/−164
• src/main/haskell/Hydra/Kusto/Kql.hs +288/−16
• src/main/haskell/Hydra/Osv/Schema.hs +86/−0
• src/main/haskell/Hydra/Parquet/Format.hs +988/−725
• src/main/haskell/Hydra/Pegasus/Coder.hs +48/−12
• src/main/haskell/Hydra/Pegasus/Language.hs +27/−1
• src/main/haskell/Hydra/Pegasus/Pdl.hs +111/−10
• src/main/haskell/Hydra/Pegasus/Serde.hs +28/−8
• src/main/haskell/Hydra/Protobuf/Any.hs +6/−0
• src/main/haskell/Hydra/Protobuf/Coder.hs +76/−29
• src/main/haskell/Hydra/Protobuf/Environment.hs +10/−0
• src/main/haskell/Hydra/Protobuf/Language.hs +28/−1
• src/main/haskell/Hydra/Protobuf/Proto3.hs +91/−0
• src/main/haskell/Hydra/Protobuf/Serde.hs +40/−10
• src/main/haskell/Hydra/Protobuf/SourceContext.hs +5/−0
• src/main/haskell/Hydra/Rust/Coder.hs +57/−3
• src/main/haskell/Hydra/Rust/Language.hs +28/−1
• src/main/haskell/Hydra/Rust/Operators.hs +53/−0
• src/main/haskell/Hydra/Rust/Serde.hs +186/−92
• src/main/haskell/Hydra/Rust/Syntax.hs +2142/−1568
• src/main/haskell/Hydra/Sql/Syntax.hs +1574/−974
• src/main/haskell/Hydra/Stac/Items.hs +55/−0
• src/main/haskell/Hydra/Workflow.hs +17/−0
• src/main/haskell/Hydra/Yaml/Coder.hs +40/−23
• src/main/haskell/Hydra/Yaml/Language.hs +27/−1
• src/main/haskell/Hydra/Yaml/Serde.hs +57/−31

@@ -15,6 +15,240 @@  --- +## [0.17.3] - 2026-08-01++Point release on the 0.17.x line, focused on **release-artifact integrity**. The 0.17.2 release shipped+two defects that every existing check missed because they validated only the generated `dist/` tree, never+the packaged artifact: the `hydra-build` sdist shipped 3 of 8 modules, and the published Java `hydra-kernel`+jar was a whole [#417](https://github.com/CategoricalData/hydra/issues/417) rename behind. This release adds+an artifact-level publish-completeness gate that inspects the actual uploaded archive, closing that class of+defect across all five registries.++### Highlights++- **Artifact-content completeness gate** ([#621](https://github.com/CategoricalData/hydra/issues/621)):+  every publish path (Hackage sdist, Maven-Java jar, Maven-Scala jar, PyPI wheel, npm tarball) now inspects+  the *packaged* archive and hard-fails if any module a package's manifest declares is missing. The gate also+  asserts the post-#417 class names are present in the Java kernel jar.++### Bug fixes++- **PyPI wheels dropped non-`hydra.*` roots** ([#621](https://github.com/CategoricalData/hydra/issues/621)):+  the wheel packaging hardcoded `packages = ["src/main/python/hydra"]`, silently omitting `hydra-pg`'s+  `com.gdblab.*` and `openGql.*` modules. The generator now ships every emitted top-level root.++### Improvements++- **CI guard for dist-tree completeness** ([#524](https://github.com/CategoricalData/hydra/issues/524)):+  asserts every manifest `mainModules` namespace is emitted into `dist/haskell`, catching the 0.17.2+  `hydra-build` truncation at the tree level (the artifact gate is the packaged-archive counterpart).+- **Manifest generation extracted** into `Hydra.ManifestGeneration`, and the structurally-unneeded #607+  sed shims dropped ([#622](https://github.com/CategoricalData/hydra/issues/622)).+- **Release-verification signing fix** ([#441](https://github.com/CategoricalData/hydra/issues/441)):+  sign the reproducible uncompressed `.tar` and verify the `.asc` against the GitHub Release asset.+- **Java CI signing gate** ([#591](https://github.com/CategoricalData/hydra/issues/591)): `publishToMavenLocal`+  skips gpg signing when no key is present.++### Internal++- Version bump to 0.17.3; `hostVersion` advanced to 0.17.2 and the temporary #417 Java/Python local-host+  shims removed now that 0.17.2 is published on the registries+  ([#417](https://github.com/CategoricalData/hydra/issues/417)).++## [0.17.2] - 2026-07-28++Point release on the 0.17.x line. Themes: promotion of the generator's routing and manifest+logic into Hydra (`hydra.build.*`), per-package API-doc publishing across Java/Scala/Python,+constraint-polymorphic arithmetic, and new effectful stream/file primitives. Includes the base64+binary-literal rename `literals.binaryToString`/`stringToBinary` → `binaryToBase64`/`base64ToBinary`,+a step toward [#417](https://github.com/CategoricalData/hydra/issues/417) (which remains in progress).++### Highlights++- **Build system promoted into Hydra**: the three generator drivers now consume `hydra.build.routing`+  ([#560](https://github.com/CategoricalData/hydra/issues/560)) and `hydra.build.manifest`+  ([#607](https://github.com/CategoricalData/hydra/issues/607)), retiring the legacy static prefix+  tables; the cold-seeder oil-and-water violation is fixed+  ([#608](https://github.com/CategoricalData/hydra/issues/608)) and guarded+  ([#617](https://github.com/CategoricalData/hydra/issues/617)).+- **Per-package API docs** for all doc-bearing hosts: JavaDoc restructured with cross-links and a fixed+  tag→CI→Pages chain ([#616](https://github.com/CategoricalData/hydra/issues/616)), plus mirrored+  Scaladoc ([#619](https://github.com/CategoricalData/hydra/issues/619)) and Python API docs+  ([#620](https://github.com/CategoricalData/hydra/issues/620)).+- **Constraint-polymorphic arithmetic**: a `numeric` type class with enforcement and value-level dispatch+  ([#566](https://github.com/CategoricalData/hydra/issues/566)), reflected on the target hosts+  ([#618](https://github.com/CategoricalData/hydra/issues/618)).++### New features++- Standard-stream primitives: `stdin`/`stdout`/`stderr` ([#526](https://github.com/CategoricalData/hydra/issues/526)).+- Recursive flag for `hydra.lib.files.listDirectory` ([#527](https://github.com/CategoricalData/hydra/issues/527)).+- Hydra-specific regex syntax with per-target translation (`hydra.read.regex` / `hydra.show.regex`)+  ([#567](https://github.com/CategoricalData/hydra/issues/567)).+- Constraint-polymorphic arithmetic: `numeric` type class + value-level dispatch+  ([#566](https://github.com/CategoricalData/hydra/issues/566)).+- Aggregated Java + Scala Maven publishing into a single Central Portal deployment+  ([#591](https://github.com/CategoricalData/hydra/issues/591)).++### Improvements++- Generator drivers consume `hydra.build.routing` ([#560](https://github.com/CategoricalData/hydra/issues/560))+  and `hydra.build.manifest` ([#607](https://github.com/CategoricalData/hydra/issues/607)).+- Fixed the cold-seeder oil-and-water violation ([#608](https://github.com/CategoricalData/hydra/issues/608))+  and extended `check-oil-and-water.py` to catch cold-seeder imports of unpublished `Hydra.Build.*`+  ([#617](https://github.com/CategoricalData/hydra/issues/617)).+- Moved non-kernel packages to strict validation, clearing the #575 backlog+  ([#580](https://github.com/CategoricalData/hydra/issues/580)).+- Decoupled `Hydra.Sources.Test.All` from `Hydra.Sources.All`'s re-export list+  ([#601](https://github.com/CategoricalData/hydra/issues/601)).+- Renamed `hydra.json.schema` to resolve the module-vs-namespace-prefix conflict that broke+  file-per-module hosts ([#532](https://github.com/CategoricalData/hydra/issues/532)).+- Coders route `hydra.lib.*` overlay imports by overlay-module existence, not name-matching+  `hydra.lib.defaults` ([#568](https://github.com/CategoricalData/hydra/issues/568)).+- Per-package JavaDoc/Scaladoc/Python-doc publishing+  ([#616](https://github.com/CategoricalData/hydra/issues/616),+  [#619](https://github.com/CategoricalData/hydra/issues/619),+  [#620](https://github.com/CategoricalData/hydra/issues/620)).+- Aligned Java-host Scala/TypeScript generation with Haskell on expression layout (line-wrapping,+  declaration order) ([#612](https://github.com/CategoricalData/hydra/issues/612)).++### Bug fixes++- **TypeScript** — added the missing CI job (zero prior coverage)+  ([#571](https://github.com/CategoricalData/hydra/issues/571)); fixed the+  `verify-distribution.sh` smoke-test import so the gate actually gates+  ([#578](https://github.com/CategoricalData/hydra/issues/578)); emit `hydra.parse.regex`'s+  `regexSequence` before its alternation use (TS2448)+  ([#604](https://github.com/CategoricalData/hydra/issues/604)).+- **Build and sync** — `sync.sh` Phase 3 digest-cache now sees cross-package deps on moved kernel+  symbols, fixing stale downstream output ([#606](https://github.com/CategoricalData/hydra/issues/606)).+- **Numeric constraints** — `#566` polymorphism now reflected on the target hosts (targets were+  monomorphizing `int32->int32->int32`) ([#618](https://github.com/CategoricalData/hydra/issues/618)).++---++## [0.17.1] - 2026-07-18++Consolidation release on the 0.17.x line, built against published 0.17.0 hosts. Themes:+generated term-reference DSLs, a translingual package-validation framework, promotion of the+build system into Hydra (`hydra-build`), and broad TypeScript-host and cross-host hardening.++### Highlights++- **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):+  kernel term modules now emit one typed, rename-safe reference per definition into every target+  language; the Java and Python coder sources were pivoted onto them, retiring ~700 stringly-typed+  inline references.+- **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`+  framework with per-package `ValidationProfile`s (undeclared-dependency gate, naming/ordering/docs+  checks). See the [Validation](https://github.com/CategoricalData/hydra/wiki/Validation) wiki page.+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546)):+  build-orchestration logic that lived only in host scripts is now translingual Hydra+  (`hydra.build.*`), extracted into a dedicated package.++### New features++- Generated term-reference DSLs ([#467](https://github.com/CategoricalData/hydra/issues/467));+  follow-ups: `TypedName` refs to derived encode/decode/show+  ([#555](https://github.com/CategoricalData/hydra/issues/555)), non-kernel packages+  ([#556](https://github.com/CategoricalData/hydra/issues/556)).+- Translingual package-validation framework ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)).+- DSL-authoring registration guards: fail-fast completeness checks for the Java/Python/Scala DSL sources+  ([#554](https://github.com/CategoricalData/hydra/issues/554)).+- `hydra-build` package: `hydra.build.modules`+  ([#529](https://github.com/CategoricalData/hydra/issues/529)), `hydra.build.reconcile`+  ([#530](https://github.com/CategoricalData/hydra/issues/530)), extracted from the kernel+  ([#546](https://github.com/CategoricalData/hydra/issues/546)).+- Effectful `hydra.lib.system` primitive library ([#498](https://github.com/CategoricalData/hydra/issues/498)).+- SHA-256 cryptographic hash primitive in `hydra.lib` ([#524](https://github.com/CategoricalData/hydra/issues/524)).+- `hydra-jvm` package: shared JVM serde helpers relocated out of `hydra.java.serde`+  ([#505](https://github.com/CategoricalData/hydra/issues/505)).+- Internalized the Hydra-TinkerPop bindings (formerly HydraPop)+  ([#442](https://github.com/CategoricalData/hydra/issues/442)).+- Compact unit-valued variants in the JSON encoding ([#520](https://github.com/CategoricalData/hydra/issues/520)).+- Structured generation-provenance record (digest v2) ([#413](https://github.com/CategoricalData/hydra/issues/413),+  [#523](https://github.com/CategoricalData/hydra/issues/523)).+- Metadata sidecar + content/version-addressed freshness (`moduleFormatVersion`)+  ([#415](https://github.com/CategoricalData/hydra/issues/415)).+- Worker + issue hierarchy: agent/worker framework, cross-worktree messaging, issue-proposal queue+  (contributor process only) ([#557](https://github.com/CategoricalData/hydra/issues/557)).++### Improvements++- Type inference for annotations ([#229](https://github.com/CategoricalData/hydra/issues/229)).+- Fixed the signature / definition split in primitive definitions+  ([#502](https://github.com/CategoricalData/hydra/issues/502)).+- DSL usability passes across the host-native Java/Python/Scala surfaces+  ([#430](https://github.com/CategoricalData/hydra/issues/430),+  [#553](https://github.com/CategoricalData/hydra/issues/553)).+- Audited the Scala and Lisp-family coders for the unconditional `hydra.lib.*` overlay-import rewrite+  ([#569](https://github.com/CategoricalData/hydra/issues/569)).++### Bug fixes++- **TypeScript host** — V8 stack budget on ts→Java ([#390](https://github.com/CategoricalData/hydra/issues/390));+  effectful libs not generated / 484 tsc errors ([#503](https://github.com/CategoricalData/hydra/issues/503));+  15 effect/file inference cases ([#504](https://github.com/CategoricalData/hydra/issues/504));+  ts→ts self-host regression ([#507](https://github.com/CategoricalData/hydra/issues/507)); npm packages+  bundling a duplicate kernel ([#584](https://github.com/CategoricalData/hydra/issues/584)); broken npm+  entry points ([#587](https://github.com/CategoricalData/hydra/issues/587));+  `hydra.test.build.modules.allTests` gen-universe gap ([#588](https://github.com/CategoricalData/hydra/issues/588)).+- **TypeScript coder** — reactivated `hydra.lib.*` tests: lazy show-calling let bindings + compact+  `LiteralType` expansion ([#564](https://github.com/CategoricalData/hydra/issues/564)); `binaryToBytes`+  registration + base64 decode in `decodeUtf8` ([#561](https://github.com/CategoricalData/hydra/issues/561));+  `hydra.test.build.*` emission after the #546 split+  ([#570](https://github.com/CategoricalData/hydra/issues/570)); `HYDRA_DEFAULT_IMPLS` in the test runner+  ([#536](https://github.com/CategoricalData/hydra/issues/536)); overlay-import rewrite no longer captures+  `hydra.lib.defaults` ([#565](https://github.com/CategoricalData/hydra/issues/565)).+- **Lisp family** — clj→clj bootstrap hang in `generate_source_files`+  ([#479](https://github.com/CategoricalData/hydra/issues/479)); Common Lisp `test_graph.lisp` loader+  forward-reference ([#496](https://github.com/CategoricalData/hydra/issues/496)); Scheme maps+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)); Emacs Lisp+  bootstrap `wrong-type-argument (listp :string)` ([#586](https://github.com/CategoricalData/hydra/issues/586));+  `hydra.build.*` regeneration into the Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)).+- **Kernel and coders** — Java binary-literal signed-byte emission+  ([#528](https://github.com/CategoricalData/hydra/issues/528)); `hydra.json.Decode.fromJson`+  parametric-type support ([#531](https://github.com/CategoricalData/hydra/issues/531)); stale 2-param+  `Coder` shape in Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552));+  Java Javadoc ampersand escaping ([#493](https://github.com/CategoricalData/hydra/issues/493)); Scala+  coder over-generalizing `Schema[S,T,V,E]` args, breaking `hydra-pg`+  ([#589](https://github.com/CategoricalData/hydra/issues/589)); kernel dead-code/TODO cleanup+  ([#538](https://github.com/CategoricalData/hydra/issues/538)).+- **Publishing and packaging** — self-broken 0.16.0 `hydra-kernel`/`hydra-python` wheels+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).+- **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts+  ([#525](https://github.com/CategoricalData/hydra/issues/525)); standalone-kernel SHA dependency+  ([#542](https://github.com/CategoricalData/hydra/issues/542)); lexicon's empty Types section+  ([#539](https://github.com/CategoricalData/hydra/issues/539)); silent lexicon-generation failure since+  the coders moved to in-memory synthesis ([#448](https://github.com/CategoricalData/hydra/issues/448));+  duplicated generated-file header in `generate-head-haskell-build.py`+  ([#540](https://github.com/CategoricalData/hydra/issues/540)); `.gitignore` untracking 41 duplicate+  overlaid-runtime copies under `dist/haskell/` ([#501](https://github.com/CategoricalData/hydra/issues/501));+  `bin/prepare-release.sh` Java quality check repointed to `dist/java/hydra-pg` tests after+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).+- **Tests and CI** — restored default-primitive-implementation testing+  ([#388](https://github.com/CategoricalData/hydra/issues/388),+  [#549](https://github.com/CategoricalData/hydra/issues/549)); reactivated ignored kernel test cases+  ([#513](https://github.com/CategoricalData/hydra/issues/513),+  [#550](https://github.com/CategoricalData/hydra/issues/550)); wired + split out the regression harnesses+  ([#535](https://github.com/CategoricalData/hydra/issues/535),+  [#563](https://github.com/CategoricalData/hydra/issues/563)); Scala/Go/Lisp self-containment gates+  ([#537](https://github.com/CategoricalData/hydra/issues/537)); manifest-JSON-tracked CI check+  ([#541](https://github.com/CategoricalData/hydra/issues/541)); per-package test-digest freshness+  ([#551](https://github.com/CategoricalData/hydra/issues/551)); overlay-file restoration in+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)); DSL-aware+  sync-freshness fingerprint ([#562](https://github.com/CategoricalData/hydra/issues/562)).++### Documentation++- Corrected 0.17.0 Maven coordinates and added npm/Scala release channels, TypeScript/Scala/Lisp+  Getting-started sections, and issue/PR templates+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).++---+ ## [0.17.0] - 2026-07-01  Major themes: first-class support for effects and I/O in the kernel, TypeScript and

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-ext-version:        0.17.0+version:        0.17.4 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@@ -53,9 +53,9 @@       Hydra.Graphql.Serde       Hydra.Graphql.Syntax       Hydra.Iana.Linkrelations-      Hydra.Json.Schema       Hydra.Json.Schema.Coder       Hydra.Json.Schema.Language+      Hydra.Json.Schema.Model       Hydra.Json.Schema.Serde       Hydra.Kusto.Kql       Hydra.Osv.Schema@@ -90,7 +90,7 @@       base >=4.19.0 && <4.22     , bytestring >=0.11.5 && <0.13     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.0-    , hydra-rdf ==0.17.0+    , hydra-kernel ==0.17.4+    , hydra-rdf ==0.17.4     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -1,9 +1,11 @@ -- 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, map, pure, sum)@@ -11,13 +13,14 @@ 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 AtlasAttributeDef_Cardinality),+    atlasAttributeDefCardinality :: (Maybe AtlasAttributeDefCardinality),     atlasAttributeDefValuesMinCount :: Int,     atlasAttributeDefValuesMaxCount :: Int,     atlasAttributeDefIsUnique :: Bool,@@ -26,44 +29,73 @@     atlasAttributeDefDefaultValue :: (Maybe String),     atlasAttributeDefDescription :: (Maybe String),     atlasAttributeDefSearchWeight :: Int,-    atlasAttributeDefIndexType :: (Maybe AtlasAttributeDef_IndexType),+    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"-data AtlasAttributeDef_Cardinality =-  AtlasAttributeDef_CardinalitySingle |-  AtlasAttributeDef_CardinalityList |-  AtlasAttributeDef_CardinalitySet++-- | The cardinality of an Atlas attribute: single-valued, a list, or a set+data AtlasAttributeDefCardinality =+  AtlasAttributeDefCardinalitySingle |+  AtlasAttributeDefCardinalityList |+  AtlasAttributeDefCardinalitySet   deriving (Eq, Ord, Read, Show)-_AtlasAttributeDef_Cardinality = Core.Name "hydra.atlas.AtlasAttributeDef_Cardinality"-_AtlasAttributeDef_Cardinality_single = Core.Name "single"-_AtlasAttributeDef_Cardinality_list = Core.Name "list"-_AtlasAttributeDef_Cardinality_set = Core.Name "set"-data AtlasAttributeDef_IndexType =-  AtlasAttributeDef_IndexTypeDefault |-  AtlasAttributeDef_IndexTypeString++_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)-_AtlasAttributeDef_IndexType = Core.Name "hydra.atlas.AtlasAttributeDef_IndexType"-_AtlasAttributeDef_IndexType_default = Core.Name "default"-_AtlasAttributeDef_IndexType_string = Core.Name "string"++_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 {@@ -80,28 +112,46 @@     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 {@@ -114,12 +164,19 @@     -- | 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 {@@ -127,19 +184,29 @@     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 |@@ -152,14 +219,25 @@   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"

@@ -1,17 +1,23 @@ -- 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@@ -21,6 +27,7 @@ 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@@ -29,10 +36,13 @@ 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@@ -42,8 +52,9 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci 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 Errors.Error -> Coders.Adapter t0 Core.Type t1 t2 Errors.Error+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.cases ann ad (\n -> Coders.Adapter {       Coders.adapterIsLossy = (Coders.adapterIsLossy ad),@@ -52,6 +63,11 @@         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 =@@ -153,7 +169,7 @@                       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.stringToBinary v2)))) (\t -> Eithers.map (\b -> Model.ValueString (Literals.binaryToString b)) (ExtractCore.binary (Graph.Graph {+              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,@@ -169,25 +185,25 @@                     env2 = Pairs.second prepResult                 in (Eithers.bind (findAvroPrimaryKeyField cx qname avroFields) (\pk ->                   let encodePair =-                          \cx1 -> \entry ->+                          \entry ->                             let k = Pairs.first entry                                 v = Pairs.second entry-                            in (Optionals.cases (Maps.lookup k adaptersByFieldName) (err cx1 (Strings.cat [+                            in (Optionals.cases (Maps.lookup k adaptersByFieldName) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [                               "unrecognized field for ",                               (showQname qname),                               ": ",-                              k])) (\fad -> Eithers.map (\v_ -> Core.Field {+                              k])))) (\fad -> Eithers.map (\v_ -> Core.Field {                               Core.fieldName = (Core.Name k),                               Core.fieldTerm = v_}) (Coders.coderEncode (Coders.adapterCoder (Pairs.second fad)) v)))                       decodeField =-                              \cx1 -> \fld ->+                              \fld ->                                 let k = Core.unName (Core.fieldName fld)                                     v = Core.fieldTerm fld-                                in (Optionals.cases (Maps.lookup k adaptersByFieldName) (err cx1 (Strings.cat [+                                in (Optionals.cases (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)))+                                  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 =@@ -204,9 +220,9 @@                         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 cx e) v2)),+                            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 cx fld) (Core.recordFields v2)))}},+                          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@@ -216,7 +232,7 @@                           Environment.avroEnvironmentNamedAdapters = (Environment.avroEnvironmentNamedAdapters env3),                           Environment.avroEnvironmentNamespace = lastNs,                           Environment.avroEnvironmentElements = (Environment.avroEnvironmentElements env3)}-            in (Right (annotateAdapter ann ad, env4)))) (\_ad -> err cx (Strings.cat2 "Avro named type defined more than once: " (showQname qname))))+            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 {@@ -279,7 +295,7 @@             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.stringToBinary v2)))) (\t -> Eithers.map (\b -> Model.ValueString (Literals.binaryToString b)) (ExtractCore.binary (Graph.Graph {+            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,@@ -300,7 +316,7 @@             Graph.graphTypeVariables = Sets.empty}) t))         Schema.SchemaReference v0 ->           let qname = parseAvroName (Environment.avroEnvironmentNamespace env0) v0-          in (Optionals.cases (getAvroHydraAdapter qname env0) (err cx (Strings.cat2 "Referenced Avro type has not been defined: " (showQname qname))) (\ad -> Right (ad, env0)))+          in (Optionals.cases (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 =@@ -327,7 +343,7 @@                               Coders.coderDecode = (\t -> case t of                                 Core.TermOptional v1 -> Optionals.cases v1 (Right Model.ValueNull) (\term_ -> Coders.coderDecode (Coders.adapterCoder ad) term_))}},                           env1)))-          in (Logic.ifElse (Equality.gt (Lists.length nonNulls) 1) (err cx "general-purpose unions are not yet supported") (Optionals.cases (Lists.maybeHead nonNulls) (err cx "cannot generate the empty type") (\nonNullHead -> Logic.ifElse hasNull (forOptional nonNullHead) (Eithers.bind (avroHydraAdapter cx nonNullHead env0) (\adEnv ->+          in (Logic.ifElse (Ordering.gt (Lists.length nonNulls) 1) (err cx "general-purpose unions are not yet supported") (Optionals.cases (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 (@@ -337,6 +353,7 @@                 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 =@@ -346,10 +363,11 @@       in (Names.unqualifyName (Util.QualifiedName {         Util.qualifiedNameModuleName = (Optionals.map (\s -> Packaging.ModuleName s) mns),         Util.qualifiedNameLocal = local}))-avro_foreignKey :: String-avro_foreignKey = "@foreignKey"-avro_primaryKey :: String-avro_primaryKey = "@primaryKey"++-- | 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 =@@ -357,6 +375,7 @@       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 =@@ -370,24 +389,29 @@             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 =@@ -395,23 +419,27 @@       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.cat (Lists.map (\f -> primaryKeyE cx f) avroFields)-      in (Logic.ifElse (Lists.null keys) (Right Nothing) (Logic.ifElse (Equality.equal (Lists.length keys) 1) (Right (Lists.maybeHead keys)) (err cx (Strings.cat2 "multiple primary key fields for " (showQname qname)))))+      let keys = Optionals.givens (Lists.map (\f -> primaryKeyE cx f) avroFields)+      in (Logic.ifElse (Lists.null 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.cases (Maps.lookup avro_foreignKey (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_ ->+    Optionals.cases (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.cases 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 =@@ -420,6 +448,7 @@       Model.ValueString v0 -> Right v0       Model.ValueNumber v0 -> Right (Literals.showDecimal 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 =@@ -427,26 +456,32 @@       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.cases (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.pure 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.fromOptional name_ (Lists.maybeLast parts)+          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.intercalate "." ps) (Lists.maybeInit parts)),+        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.intercalate s (Strings.splitOn "${}" pat))+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 :: 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@@ -463,7 +498,7 @@               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_)-                        _ -> err cx "expected variable"+                        _ -> Left (Errors.ErrorOther (Errors.OtherError "expected variable"))               forTypeAndCoder =                       \env2 -> \ad1 -> \typ -> \cdr -> Right (                         Coders.Adapter {@@ -482,18 +517,21 @@               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)-                  _ -> err cx "Expected JSON array"),+                  _ -> 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.cat2 "unsupported type annotated as foreign key: " "unknown"))))) (\adEnv ->+            _ -> 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 :: 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@@ -504,12 +542,14 @@             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.cases (Maps.lookup avro_primaryKey (Schema.fieldAnnotations f)) Nothing (\v -> Eithers.either (\_ -> Nothing) (\s -> Just (Environment.AvroPrimaryKey {+    Optionals.cases (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 =@@ -517,13 +557,15 @@       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.cases (Maps.lookup fname m) (err cx (Strings.cat [+    Optionals.cases (Maps.lookup fname m) (err cx (Strings.concat [       "required attribute ",-      (Literals.showString fname),+      (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 =@@ -555,13 +597,15 @@                     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.cat2 (Optionals.cases mns "" (\ns -> Strings.cat2 ns ".")) local)+      in (Strings.concat2 (Optionals.cases 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 =@@ -570,7 +614,7 @@           readAndWrap = \reader -> \wrapper -> Optionals.cases (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.readBoolean x) (\b -> Core.LiteralBoolean b)+          Core.LiteralTypeBoolean -> readAndWrap (\x -> Literals.parseBoolean x) (\b -> Core.LiteralBoolean b)           Core.LiteralTypeInteger v1 -> case v1 of             Core.IntegerTypeBigint -> readAndWrap (\x -> Literals.readBigint x) (\i -> Core.LiteralInteger (Core.IntegerValueBigint i))             Core.IntegerTypeInt8 -> readAndWrap (\x -> Literals.readInt8 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt8 i))@@ -584,12 +628,13 @@           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.showBoolean v1)+        Core.LiteralBoolean v1 -> Right (Literals.printBoolean v1)         Core.LiteralInteger v1 -> Right (case v1 of           Core.IntegerValueBigint v2 -> Literals.showBigint v2           Core.IntegerValueInt8 v2 -> Literals.showInt8 v2@@ -604,10 +649,11 @@         _ -> unexpectedE cx "boolean, integer, or string" "other literal"       Core.TermOptional v0 -> Optionals.cases 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.cat [+    err cx (Strings.concat [       "Expected ",       expected,       ", found: ",

@@ -1,18 +1,24 @@ -- 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@@ -29,18 +35,23 @@ 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, map, pure, sum) import qualified Data.Scientific as Sci 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 =@@ -55,16 +66,19 @@         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 =@@ -130,7 +144,7 @@                                       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)))),+                          in (Eithers.map (\pairs -> Model.ValueObject pairs) (Eithers.mapList encodeEntry (Maps.toList v3)))),                       Coders.coderDecode = (\j -> case j of                         Model.ValueObject v3 ->                           let decodeEntry =@@ -168,7 +182,7 @@                   _ -> 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.cases (Maps.lookup v0 (Environment.encodeEnvironmentEmitted env)) (Optionals.cases (Maps.lookup v0 (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.cat2 "referenced type not found: " (Core.unName v0))) (\refType -> encodeTypeInner cx (Just v0) refType env)) (\existingAd -> Right (+        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Environment.encodeEnvironmentEmitted env)) (Optionals.cases (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),@@ -176,16 +190,18 @@             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.cases (Maps.lookup name_ (Environment.encodeEnvironmentTypeMap env)) (err cx (Strings.cat2 "type not found in type map: " (Literals.showString (Core.unName name_)))) (\typ -> encodeTypeInner cx (Just name_) typ env)+    Optionals.cases (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.fromOptional (typeToName typ) mName+          typeName = Optionals.withDefault (typeToName typ) mName           avroAnnotations = hydraAnnotationsToAvro annotations           avroSchema =                   Schema.SchemaNamed (Schema.Named {@@ -207,7 +223,7 @@                         Core.TermInject v0 ->                           let fname = Core.injectionField v0                           in (Right (Model.ValueString (localName (Core.fieldName fname))))-                        _ -> err cx "expected union term for enum"),+                        _ -> 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,@@ -219,9 +235,11 @@                     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 =@@ -234,6 +252,7 @@             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 =@@ -271,14 +290,18 @@           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 :: 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@@ -290,6 +313,7 @@             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 =@@ -297,13 +321,16 @@       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 =@@ -341,6 +368,7 @@           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 =@@ -354,6 +382,7 @@       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 =@@ -377,31 +406,32 @@           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.binaryToString v2))) (\j -> case j of-          Model.ValueString v1 -> Right (Core.TermLiteral (Core.LiteralBinary (Literals.stringToBinary v1))))+            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.fromOptional s (Lists.maybeLast parts))+      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.intercalate "." ps) (Lists.maybeInit parts)))+      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 :: 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.fromOptional (typeToName typ) mName+      let typeName = Optionals.withDefault (typeToName typ) mName       in (Optionals.cases (Maps.lookup typeName (Environment.encodeEnvironmentEmitted env0)) (Eithers.bind (foldFieldAdapters cx fieldTypes env0) (\faResult ->         let fieldAdapters = Pairs.first faResult             env1 = Pairs.second faResult@@ -432,10 +462,9 @@                       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 :: 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 =@@ -447,26 +476,28 @@                               \nameAd ->                                 let fname = Pairs.first nameAd                                     ad = Pairs.second nameAd-                                    fTerm = Optionals.fromOptional Core.TermUnit (Maps.lookup fname fieldMap)+                                    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))+                  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 decodeField =-                              \nameAd ->-                                let fname = Pairs.first nameAd-                                    ad = Pairs.second nameAd-                                    jv = Optionals.fromOptional Model.ValueNull (Maps.lookup (localName fname) (Maps.fromList v0))-                                in (Eithers.map (\t -> Core.Field {-                                  Core.fieldName = fname,-                                  Core.fieldTerm = t}) (Coders.coderDecode (Coders.adapterCoder ad) jv))+                      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 =@@ -476,9 +507,9 @@         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.binaryToString 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 ->+      Core.TermMap v0 -> Model.ValueObject (Lists.map (\entry ->         let k = Pairs.first entry             v = Pairs.second entry         in (@@ -487,9 +518,10 @@               Core.LiteralString v2 -> v2               _ -> "<key>"             _ -> "<key>",-          (termToJsonValue v))) (Maps.toList v0)))+          (termToJsonValue v))) (Maps.toList v0))       Core.TermRecord v0 -> Logic.ifElse (Lists.null (Core.recordFields v0)) Model.ValueNull (Model.ValueString "<record>")       _ -> Model.ValueString "<term>"+ -- | Generate a default name for an anonymous type typeToName :: Core.Type -> Core.Name typeToName t =@@ -497,6 +529,7 @@       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 =@@ -517,7 +550,7 @@                       Schema.fieldOrder = Nothing,                       Schema.fieldAliases = Nothing,                       Schema.fieldAnnotations = Maps.empty}) fieldAdapters-          typeName = Optionals.fromOptional (typeToName typ) mName+          typeName = Optionals.withDefault (typeToName typ) mName           avroAnnotations = hydraAnnotationsToAvro annotations           avroSchema =                   Schema.SchemaNamed (Schema.Named {@@ -543,26 +576,27 @@                                         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))-                        _ -> err cx "expected union term"),+                          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 findActive =-                                  \remaining -> Optionals.cases (Lists.uncons remaining) (err cx "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) (Maps.fromList v0)-                                    in (Optionals.cases 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))))+                          let mm = Maps.fromList v0+                              findActive =+                                      \remaining -> Optionals.cases (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.cases 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)-                        _ -> err cx "expected JSON object for union-as-record")}}+                        _ -> Left (Errors.ErrorOther (Errors.OtherError "expected JSON object for union-as-record")))}}           env2 =                   Environment.EncodeEnvironment {                     Environment.encodeEnvironmentTypeMap = (Environment.encodeEnvironmentTypeMap env1),

@@ -1,7 +1,9 @@ -- 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@@ -10,17 +12,25 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Map as M--- | 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 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 {@@ -28,9 +38,13 @@     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 {@@ -38,22 +52,28 @@     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"--- | 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 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 {@@ -61,6 +81,9 @@     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"

@@ -1,14 +1,20 @@ -- 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@@ -17,10 +23,13 @@ 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@@ -29,6 +38,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci+ -- | Language constraints for Apache Avro avroLanguage :: Coders.Language avroLanguage =@@ -40,7 +50,23 @@         Coders.languageConstraintsIntegerTypes = integerTypes,         Coders.languageConstraintsTermVariants = termVariants,         Coders.languageConstraintsTypeVariants = typeVariants,-        Coders.languageConstraintsTypes = typePredicate}}+        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 [

@@ -1,19 +1,27 @@ -- 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, map, pure, sum) import qualified Data.Scientific as Sci 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)@@ -21,9 +29,14 @@     -- | 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@@ -41,27 +54,45 @@     -- | 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@@ -76,31 +107,52 @@     -- | 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 |@@ -119,22 +171,37 @@   -- | 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 |@@ -144,15 +211,25 @@   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"

@@ -1,15 +1,21 @@ -- 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@@ -27,9 +33,12 @@ 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@@ -39,162 +48,237 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci 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))}-avro_aliases :: String-avro_aliases = "aliases"-avro_array :: String-avro_array = "array"-avro_ascending :: String-avro_ascending = "ascending"-avro_boolean :: String-avro_boolean = "boolean"-avro_bytes :: String-avro_bytes = "bytes"-avro_default :: String-avro_default = "default"-avro_descending :: String-avro_descending = "descending"-avro_doc :: String-avro_doc = "doc"-avro_double :: String-avro_double = "double"-avro_enum :: String-avro_enum = "enum"-avro_fields :: String-avro_fields = "fields"-avro_fixed :: String-avro_fixed = "fixed"-avro_float :: String-avro_float = "float"-avro_ignore :: String-avro_ignore = "ignore"-avro_int :: String-avro_int = "int"-avro_items :: String-avro_items = "items"-avro_long :: String-avro_long = "long"-avro_map :: String-avro_map = "map"-avro_name :: String-avro_name = "name"-avro_namespace :: String-avro_namespace = "namespace"-avro_null :: String-avro_null = "null"-avro_order :: String-avro_order = "order"-avro_record :: String-avro_record = "record"-avro_size :: String-avro_size = "size"-avro_string :: String-avro_string = "string"-avro_symbols :: String-avro_symbols = "symbols"-avro_type :: String-avro_type = "type"-avro_values :: String-avro_values = "values"++-- | 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 avro_aliases m) (\mArr -> Optionals.cases mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.pure strs) (Eithers.mapList (expectStringE cx) arr)))+    Eithers.bind (optArrayE cx avroAliases m) (\mArr -> Optionals.cases mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.pure 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 avro_items m) (\items -> Eithers.map (\s -> Schema.SchemaArray (Schema.Array {+    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 avro_symbols m) (\syms -> Eithers.bind (Eithers.mapList (expectStringE cx) syms) (\symbols -> Eithers.bind (optStringE cx avro_default m) (\defVal -> Right (Schema.NamedTypeEnum (Schema.Enum {+    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 avro_name m) (\name -> Eithers.bind (optStringE cx avro_doc m) (\fdoc -> Eithers.bind (requireE cx avro_type m) (\typeJson -> Eithers.bind (decodeSchema cx typeJson) (\fieldType -> Eithers.bind (Eithers.bind (optStringE cx avro_order m) (\mOrd -> Eithers.mapOptional (decodeOrder cx) mOrd)) (\order -> Eithers.bind (decodeAliases cx m) (\aliases -> Right (Schema.Field {+    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 avro_default m),+      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 avro_size m) (\n ->+    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 avro_values m) (\values -> Eithers.map (\s -> Schema.SchemaMap (Schema.Map {+    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 avro_name m) (\name -> Eithers.bind (optStringE cx avro_namespace m) (\ns -> Eithers.bind (optStringE cx avro_doc m) (\sdoc -> Eithers.bind (decodeAliases cx m) (\aliases -> Eithers.bind namedTypeResult (\namedType -> Right (Schema.SchemaNamed (Schema.Named {+    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.cases (decodePrimitiveName typeName) (err cx (Strings.cat [+    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.cases (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.cat [+    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 avro_fields m) (\fieldJsons -> Eithers.bind (Eithers.mapList (\fj -> Eithers.bind (expectObjectE cx fj) (\fm -> decodeField cx fm)) fieldJsons) (\fields -> Right (Schema.NamedTypeRecord (Schema.Record {+    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.cases (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 -> Eithers.bind (requireStringE cx avro_type (Maps.fromList v0)) (\typeName -> decodeObjectSchema cx (Maps.fromList v0) typeName)-      _ -> err cx (Strings.cat [+      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.cat2 "@" (Pairs.first entry), (Pairs.second entry))) (Maps.toList m)+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 ([+    Model.ValueObject [       ("type", (Model.ValueString "array")),-      ("items", (encodeSchema (Schema.arrayItems arr)))])+      ("items", (encodeSchema (Schema.arrayItems arr)))]+ -- | Encode an Avro enum type as key-value pairs encodeEnum :: Schema.Enum -> [(String, Model.Value)] encodeEnum e =@@ -205,10 +289,11 @@         ("symbols", (Model.ValueArray (Lists.map (\s -> Model.ValueString s) (Schema.enumSymbols e))))],       (Optionals.cases (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 [+    Model.ValueObject (Lists.concat [       [         ("name", (Model.ValueString (Schema.fieldName f)))],       [@@ -221,23 +306,26 @@         encodeOrder o])),       (Optionals.cases (Schema.fieldAliases f) [] (\als -> [         ("aliases", (Model.ValueArray (Lists.map (\a -> Model.ValueString a) als)))])),-      (encodeAnnotations (Schema.fieldAnnotations f))]))+      (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 ([+    Model.ValueObject [       ("type", (Model.ValueString "map")),-      ("values", (encodeSchema (Schema.mapValues mp)))])+      ("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 [+    Model.ValueObject (Lists.concat [       [         ("name", (Model.ValueString (Schema.namedName n)))],       (Optionals.cases (Schema.namedNamespace n) [] (\ns -> [@@ -247,7 +335,8 @@       (Optionals.cases (Schema.namedAliases n) [] (\als -> [         ("aliases", (Model.ValueArray (Lists.map (\a -> Model.ValueString a) als)))])),       (encodeNamedType (Schema.namedType n)),-      (encodeAnnotations (Schema.namedAnnotations n))]))+      (encodeAnnotations (Schema.namedAnnotations n))])+ -- | Encode the specific variant of a named Avro type encodeNamedType :: Schema.NamedType -> [(String, Model.Value)] encodeNamedType nt =@@ -255,6 +344,7 @@       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 =@@ -264,6 +354,7 @@         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 =@@ -276,12 +367,14 @@       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 =@@ -292,79 +385,96 @@       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 or return an error++-- | 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.cat (Lists.map (\entry ->+    Maps.fromList (Optionals.givens (Lists.map (\entry ->       let k = Pairs.first entry           v = Pairs.second entry-      in (Logic.ifElse (Equality.equal (Optionals.fromOptional 0 (Strings.maybeCharAt 0 k)) 64) (Optionals.pure (Strings.fromList (Lists.drop 1 (Strings.toList k)), v)) Nothing)) (Maps.toList m)))+      in (Logic.ifElse (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 k)) 64) (Optionals.pure (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.cases (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\a -> Optionals.pure 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.cases (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.pure 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.cases (Maps.lookup fname m) (err cx (Strings.cat [+    Optionals.cases (Maps.lookup fname m) (err cx (Strings.concat [       "required attribute ",-      (Literals.showString fname),+      (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.cat [+    err cx (Strings.concat [       "Expected ",       expected,       ", found: ",

@@ -1,68 +1,138 @@ -- 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, map, pure, sum) import qualified Data.Scientific as Sci--- | 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}++-- | 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)-_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 {++_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-    typeLevelReverseTestCaseDescription :: String,-    -- | The input Hydra type-    typeLevelReverseTestCaseType :: Core.Type,-    -- | The expected Avro schema-    typeLevelReverseTestCaseSchema :: Schema.Schema}+    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)-_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 {++_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-    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}+    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)-_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 {++_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-    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}+    schemaSerializationTestCaseDescription :: String,+    -- | The Avro schema+    schemaSerializationTestCaseSchema :: Schema.Schema,+    -- | The expected JSON representation of the schema+    schemaSerializationTestCaseJson :: Model.Value}   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"++_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 {@@ -75,11 +145,17 @@     -- | 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 {@@ -92,11 +168,17 @@     -- | 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 {@@ -109,11 +191,17 @@     -- | 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 {@@ -126,11 +214,93 @@     -- | 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 {@@ -143,99 +313,13 @@     -- | 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"--- | 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 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 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 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"

@@ -1,4 +1,5 @@ -- 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:@@ -7,10 +8,12 @@ -- |   * 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, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S+ -- | A Command describes a function or operation that can be performed on any digital twin. data Command =   Command {@@ -33,16 +36,27 @@     -- | 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 {@@ -59,21 +73,33 @@     -- | 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 {@@ -92,20 +118,31 @@     -- | 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 {@@ -122,13 +159,21 @@     -- | 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 {@@ -145,20 +190,34 @@     -- | 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@@ -170,7 +229,7 @@     -- | 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 Interface_Contents)),+    interfaceContents :: (Maybe (S.Set InterfaceContents)),     -- | A localizable description for display     interfaceDescription :: (Maybe String),     -- | A localizable name for display@@ -178,36 +237,58 @@     -- | 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 Schema_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"-data Interface_Contents =-  Interface_ContentsCommand Command |-  Interface_ContentsComponent Component |-  Interface_ContentsProperty Property |-  Interface_ContentsRelationship Relationship |-  Interface_ContentsTelemetry Telemetry++-- | 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)-_Interface_Contents = Core.Name "hydra.azure.dtld.Interface_Contents"-_Interface_Contents_command = Core.Name "command"-_Interface_Contents_component = Core.Name "component"-_Interface_Contents_property = Core.Name "property"-_Interface_Contents_relationship = Core.Name "relationship"-_Interface_Contents_telemetry = Core.Name "telemetry"++_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 {@@ -224,13 +305,21 @@     -- | 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 {@@ -247,13 +336,21 @@     -- | 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 {@@ -276,16 +373,27 @@     -- | 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 {@@ -312,201 +420,284 @@     -- | 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 Schema_Primitive |-  SchemaComplex Schema_Complex+  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 Schema_Array =-  Schema_Array {+data SchemaArray =+  SchemaArray {     -- | This must be 'Array'-    schema_ArrayType :: Iri,+    schemaArrayType :: Iri,     -- | The data type of the array elements-    schema_ArrayElementSchema :: Schema,+    schemaArrayElementSchema :: Schema,     -- | The ID of the array. If no @id is provided, the digital twin interface processor will assign one.-    schema_ArrayId :: (Maybe Dtmi),+    schemaArrayId :: (Maybe Dtmi),     -- | A comment for model authors-    schema_ArrayComment :: (Maybe String),+    schemaArrayComment :: (Maybe String),     -- | A localizable description for display-    schema_ArrayDescription :: (Maybe String),+    schemaArrayDescription :: (Maybe String),     -- | A localizable name for display-    schema_ArrayDisplayName :: (Maybe String)}+    schemaArrayDisplayName :: (Maybe String)}   deriving (Eq, Ord, Read, Show)-_Schema_Array = Core.Name "hydra.azure.dtld.Schema_Array"-_Schema_Array_type = Core.Name "type"-_Schema_Array_elementSchema = Core.Name "elementSchema"-_Schema_Array_id = Core.Name "id"-_Schema_Array_comment = Core.Name "comment"-_Schema_Array_description = Core.Name "description"-_Schema_Array_displayName = Core.Name "displayName"++_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 Schema_Complex =-  Schema_ComplexArray Schema_Array |-  Schema_ComplexEnum Schema_Enum |-  Schema_ComplexMap Schema_Map |-  Schema_ComplexObject Schema_Object+data SchemaComplex =+  SchemaComplexArray SchemaArray |+  SchemaComplexEnum SchemaEnum |+  SchemaComplexMap SchemaMap |+  SchemaComplexObject SchemaObject   deriving (Eq, Ord, Read, Show)-_Schema_Complex = Core.Name "hydra.azure.dtld.Schema_Complex"-_Schema_Complex_array = Core.Name "array"-_Schema_Complex_enum = Core.Name "enum"-_Schema_Complex_map = Core.Name "map"-_Schema_Complex_object = Core.Name "object"++_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 Schema_Enum =-  Schema_Enum {+data SchemaEnum =+  SchemaEnum {     -- | Enum-    schema_EnumType :: Iri,+    schemaEnumType :: Iri,     -- | A set of enum value and label mappings-    schema_EnumEnumValues :: [EnumValue],+    schemaEnumEnumValues :: [EnumValue],     -- | The data type for the enum values. All enum values must be of the same type.-    schema_EnumValueSchema :: IntegerOrString,+    schemaEnumValueSchema :: IntegerOrString,     -- | The ID of the enum. If no @id is provided, the digital twin interface processor will assign one.-    schema_EnumId :: (Maybe Dtmi),+    schemaEnumId :: (Maybe Dtmi),     -- | A comment for model authors-    schema_EnumComment :: (Maybe String),+    schemaEnumComment :: (Maybe String),     -- | A localizable description for display-    schema_EnumDescription :: (Maybe String),+    schemaEnumDescription :: (Maybe String),     -- | A localizable name for display-    schema_EnumDisplayName :: (Maybe String)}+    schemaEnumDisplayName :: (Maybe String)}   deriving (Eq, Ord, Read, Show)-_Schema_Enum = Core.Name "hydra.azure.dtld.Schema_Enum"-_Schema_Enum_type = Core.Name "type"-_Schema_Enum_enumValues = Core.Name "enumValues"-_Schema_Enum_valueSchema = Core.Name "valueSchema"-_Schema_Enum_id = Core.Name "id"-_Schema_Enum_comment = Core.Name "comment"-_Schema_Enum_description = Core.Name "description"-_Schema_Enum_displayName = Core.Name "displayName"++_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 Schema_Interface =-  Schema_Interface {+data SchemaInterface =+  SchemaInterface {     -- | The globally unique identifier for the schema-    schema_InterfaceId :: Dtmi,+    schemaInterfaceId :: Dtmi,     -- | The type of complex schema. This must refer to one of the complex schema classes (Array, Enum, Map, or Object).-    schema_InterfaceType :: Schema_Interface_Type,+    schemaInterfaceType :: SchemaInterfaceType,     -- | A comment for model authors-    schema_InterfaceComment :: (Maybe String),+    schemaInterfaceComment :: (Maybe String),     -- | A localizable description for display-    schema_InterfaceDescription :: (Maybe String),+    schemaInterfaceDescription :: (Maybe String),     -- | A localizable name for display-    schema_InterfaceDisplayName :: (Maybe String)}+    schemaInterfaceDisplayName :: (Maybe String)}   deriving (Eq, Ord, Read, Show)-_Schema_Interface = Core.Name "hydra.azure.dtld.Schema_Interface"-_Schema_Interface_id = Core.Name "id"-_Schema_Interface_type = Core.Name "type"-_Schema_Interface_comment = Core.Name "comment"-_Schema_Interface_description = Core.Name "description"-_Schema_Interface_displayName = Core.Name "displayName"-data Schema_Interface_Type =-  Schema_Interface_TypeArray Schema_Array |-  Schema_Interface_TypeEnum Schema_Enum |-  Schema_Interface_TypeMap Schema_Map |-  Schema_Interface_TypeObject Schema_Object++_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)-_Schema_Interface_Type = Core.Name "hydra.azure.dtld.Schema_Interface_Type"-_Schema_Interface_Type_array = Core.Name "array"-_Schema_Interface_Type_enum = Core.Name "enum"-_Schema_Interface_Type_map = Core.Name "map"-_Schema_Interface_Type_object = Core.Name "object"++_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 Schema_Map =-  Schema_Map {+data SchemaMap =+  SchemaMap {     -- | Map-    schema_MapType :: Iri,+    schemaMapType :: Iri,     -- | A description of the keys in the map-    schema_MapMapKey :: MapKey,+    schemaMapMapKey :: MapKey,     -- | A description of the values in the map-    schema_MapMapValue :: MapValue,+    schemaMapMapValue :: MapValue,     -- | The ID of the map. If no @id is provided, the digital twin interface processor will assign one.-    schema_MapId :: (Maybe Dtmi),+    schemaMapId :: (Maybe Dtmi),     -- | A comment for model authors-    schema_MapComment :: (Maybe String),+    schemaMapComment :: (Maybe String),     -- | A localizable description for display-    schema_MapDescription :: (Maybe String),+    schemaMapDescription :: (Maybe String),     -- | A localizable name for display-    schema_MapDisplayName :: (Maybe String)}+    schemaMapDisplayName :: (Maybe String)}   deriving (Eq, Ord, Read, Show)-_Schema_Map = Core.Name "hydra.azure.dtld.Schema_Map"-_Schema_Map_type = Core.Name "type"-_Schema_Map_mapKey = Core.Name "mapKey"-_Schema_Map_mapValue = Core.Name "mapValue"-_Schema_Map_id = Core.Name "id"-_Schema_Map_comment = Core.Name "comment"-_Schema_Map_description = Core.Name "description"-_Schema_Map_displayName = Core.Name "displayName"++_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 Schema_Object =-  Schema_Object {+data SchemaObject =+  SchemaObject {     -- | Object-    schema_ObjectType :: Iri,+    schemaObjectType :: Iri,     -- | A set of field descriptions, one for each field in the Object-    schema_ObjectFields :: (S.Set Field),+    schemaObjectFields :: (S.Set Field),     -- | The ID of the object. If no @id is provided, the digital twin interface processor will assign one.-    schema_ObjectId :: (Maybe Dtmi),+    schemaObjectId :: (Maybe Dtmi),     -- | A comment for model authors-    schema_ObjectComment :: (Maybe String),+    schemaObjectComment :: (Maybe String),     -- | A localizable description for display-    schema_ObjectDescription :: (Maybe String),+    schemaObjectDescription :: (Maybe String),     -- | A localizable name for display-    schema_ObjectDisplayName :: (Maybe String)}+    schemaObjectDisplayName :: (Maybe String)}   deriving (Eq, Ord, Read, Show)-_Schema_Object = Core.Name "hydra.azure.dtld.Schema_Object"-_Schema_Object_type = Core.Name "type"-_Schema_Object_fields = Core.Name "fields"-_Schema_Object_id = Core.Name "id"-_Schema_Object_comment = Core.Name "comment"-_Schema_Object_description = Core.Name "description"-_Schema_Object_displayName = Core.Name "displayName"++_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 Schema_Primitive =+data SchemaPrimitive =   -- | A boolean value-  Schema_PrimitiveBoolean |+  SchemaPrimitiveBoolean |   -- | A full-date as defined in section 5.6 of RFC 3339-  Schema_PrimitiveDate |+  SchemaPrimitiveDate |   -- | A date-time as defined in RFC 3339-  Schema_PrimitiveDateTime |+  SchemaPrimitiveDateTime |   -- | An IEEE 8-byte floating point-  Schema_PrimitiveDouble |+  SchemaPrimitiveDouble |   -- | A duration in ISO 8601 format-  Schema_PrimitiveDuration |+  SchemaPrimitiveDuration |   -- | An IEEE 4-byte floating point-  Schema_PrimitiveFloat |+  SchemaPrimitiveFloat |   -- | A signed 4-byte integer-  Schema_PrimitiveInteger |+  SchemaPrimitiveInteger |   -- | A signed 8-byte integer-  Schema_PrimitiveLong |+  SchemaPrimitiveLong |   -- | A UTF8 string-  Schema_PrimitiveString |+  SchemaPrimitiveString |   -- | A full-time as defined in section 5.6 of RFC 3339-  Schema_PrimitiveTime+  SchemaPrimitiveTime   deriving (Eq, Ord, Read, Show)-_Schema_Primitive = Core.Name "hydra.azure.dtld.Schema_Primitive"-_Schema_Primitive_boolean = Core.Name "boolean"-_Schema_Primitive_date = Core.Name "date"-_Schema_Primitive_dateTime = Core.Name "dateTime"-_Schema_Primitive_double = Core.Name "double"-_Schema_Primitive_duration = Core.Name "duration"-_Schema_Primitive_float = Core.Name "float"-_Schema_Primitive_integer = Core.Name "integer"-_Schema_Primitive_long = Core.Name "long"-_Schema_Primitive_string = Core.Name "string"-_Schema_Primitive_time = Core.Name "time"++_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 {@@ -527,17 +718,29 @@     -- | 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"

@@ -1,23 +1,28 @@ -- 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.File as File 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@@ -36,15 +41,18 @@ 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.Show.Core as ShowCore 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@@ -54,11 +62,17 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci 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 {@@ -70,6 +84,8 @@       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 {@@ -78,6 +94,8 @@         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 {@@ -86,18 +104,30 @@         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 {@@ -107,11 +137,11 @@       Syntax.templateDeclarationDeclaration = (Syntax.DeclarationFunction (Syntax.FunctionDeclaration {         Syntax.functionDeclarationPrefixSpecifiers = [],         Syntax.functionDeclarationReturnType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed "R")),-        Syntax.functionDeclarationName = (Strings.cat2 (className tname) "::accept"),+        Syntax.functionDeclarationName = (Strings.concat2 (className tname) "::accept"),         Syntax.functionDeclarationParameters = [           Syntax.Parameter {             Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType {-              Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.cat2 (visitorName tname) "<R>"))),+              Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName tname) "<R>"))),               Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})),             Syntax.parameterName = "visitor",             Syntax.parameterUnnamed = False,@@ -125,7 +155,7 @@               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.cat2 (Strings.cat2 "dynamic_cast<const " (variantName tname fname)) "*>"))),+                Syntax.functionCallOperationFunction = (Syntax.PostfixExpressionPrimary (Syntax.PrimaryExpressionIdentifier (Strings.concat2 (Strings.concat2 "dynamic_cast<const " (variantName tname fname)) "*>"))),                 Syntax.functionCallOperationArguments = [                   cppPrimaryExpressionToCppExpression (Syntax.PrimaryExpressionIdentifier "this")]}))))))}))),             Syntax.selectionStatementThenBranch = (Syntax.StatementCompound (Syntax.CompoundStatement [@@ -138,14 +168,20 @@                     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.null 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 {@@ -154,8 +190,12 @@           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 {@@ -169,12 +209,18 @@       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 {@@ -184,7 +230,7 @@       Syntax.templateDeclarationDeclaration = (cppClassDeclaration (partialVisitorName tname) [         Syntax.BaseSpecifier {           Syntax.baseSpecifierAccess = Syntax.AccessSpecifierPublic,-          Syntax.baseSpecifierName = (Strings.cat2 (visitorName tname) "<R>")}] (Just (Syntax.ClassBody (Lists.concat [+          Syntax.baseSpecifierName = (Strings.concat2 (visitorName tname) "<R>")}] (Just (Syntax.ClassBody (Lists.concat [         [           memberSpecificationPublic],         [@@ -211,15 +257,21 @@             Syntax.functionDeclarationBody = (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [               Syntax.StatementJump (Syntax.JumpStatementReturnValue (createFunctionCallExpr "otherwise" [                 createIdentifierExpr "value"]))]))})))) variants)]))))})++-- | Create a template type (e.g. std::vector<T>) 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 {@@ -230,10 +282,14 @@             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 [@@ -261,7 +317,7 @@           Syntax.functionDeclarationParameters = [             Syntax.Parameter {               Syntax.parameterType = (Syntax.TypeExpressionQualified (Syntax.QualifiedType {-                Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.cat2 (visitorName name) "<R>"))),+                Syntax.qualifiedTypeBaseType = (Syntax.TypeExpressionBasic (Syntax.BasicTypeNamed (Strings.concat2 (visitorName name) "<R>"))),                 Syntax.qualifiedTypeQualifier = Syntax.TypeQualifierLvalueRef})),               Syntax.parameterName = "visitor",               Syntax.parameterUnnamed = False,@@ -269,6 +325,8 @@           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 = @@ -309,6 +367,8 @@               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 {@@ -344,11 +404,15 @@             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 [@@ -357,10 +421,16 @@         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 = @@ -371,8 +441,12 @@         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<R(Args...)> 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 {@@ -383,6 +457,8 @@           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@@ -400,12 +476,17 @@         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.intercalate "::" (Lists.map (\seg -> Formatting.convertCaseCamelToLowerSnake seg) (Strings.splitOn "." (Packaging.unModuleName 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 [@@ -417,7 +498,7 @@           Syntax.MemberSpecificationMember (Syntax.MemberDeclarationConstructor (Syntax.ConstructorDeclaration {             Syntax.constructorDeclarationName = (className name),             Syntax.constructorDeclarationParameters = (Lists.map (\p -> Syntax.Parameter {-              Syntax.parameterType = (Optionals.fromOptional (Syntax.TypeExpressionBasic Syntax.BasicTypeInt) (Syntax.variableDeclarationType p)),+              Syntax.parameterType = (Optionals.withDefault (Syntax.TypeExpressionBasic Syntax.BasicTypeInt) (Syntax.variableDeclarationType p)),               Syntax.parameterName = (Syntax.variableDeclarationName p),               Syntax.parameterUnnamed = False,               Syntax.parameterDefaultValue = Nothing}) constructorParams),@@ -427,6 +508,8 @@                 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 = @@ -457,12 +540,16 @@         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 = @@ -472,10 +559,14 @@         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.cat2 "unexpected type in definition: " (ShowCore.type_ typ))))+        _ -> 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 [@@ -489,12 +580,16 @@         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 [@@ -512,19 +607,29 @@         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 = @@ -535,9 +640,13 @@               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 = @@ -549,6 +658,8 @@         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 = @@ -558,6 +669,8 @@                     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 = @@ -567,35 +680,53 @@           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.cat2 (Names.localNameOf name) "PartialVisitor")+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 {@@ -603,7 +734,12 @@       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.cat2 (Names.localNameOf tname) (Formatting.capitalize (Core.unName fname)))+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.cat2 (Names.localNameOf name) "Visitor")+visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor")

@@ -1,13 +1,16 @@ -- 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, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Map as M+ -- | Environment for C++ code generation data CppEnvironment =   CppEnvironment {@@ -16,6 +19,9 @@     -- | 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"

@@ -1,14 +1,20 @@ -- 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@@ -18,9 +24,12 @@ 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@@ -30,6 +39,7 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S+ -- | Language constraints for C++ cppLanguage :: Coders.Language cppLanguage =@@ -41,7 +51,23 @@         Coders.languageConstraintsIntegerTypes = integerTypes,         Coders.languageConstraintsTermVariants = termVariants,         Coders.languageConstraintsTypeVariants = typeVariants,-        Coders.languageConstraintsTypes = typePredicate}}+        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 [@@ -99,6 +125,7 @@           Variants.TypeVariantVariable,           Variants.TypeVariantWrap]     typePredicate = \_ -> True+ -- | A set of reserved words in C++ cppReservedWords :: S.Set String cppReservedWords =

@@ -1,7 +1,9 @@ -- 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@@ -9,10 +11,14 @@ 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@@ -28,9 +34,12 @@ 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@@ -39,21 +48,26 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci+ -- | 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 =@@ -65,8 +79,9 @@           local = Util.qualifiedNameLocal qualName           cppLocal = sanitizeCppName (Formatting.convertCase Util.CaseConventionCamel conv local)           cppNs =-                  \nsVal -> Strings.intercalate "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal)))-      in (Logic.ifElse isQualified (Optionals.cases (Maps.lookup name boundVars) (Optionals.cases mns cppLocal (\nsVal -> Strings.cat2 (cppNs nsVal) (Strings.cat2 "::" cppLocal))) (\n -> n)) cppLocal)+                  \nsVal -> Strings.join "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName nsVal)))+      in (Logic.ifElse isQualified (Optionals.cases (Maps.lookup name boundVars) (Optionals.cases 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 =@@ -76,45 +91,57 @@           qualName = Names.qualifyName name           mns = Util.qualifiedNameModuleName qualName           local = Util.qualifiedNameLocal qualName-      in (Optionals.cases (Maps.lookup name boundVars) (Logic.ifElse (Equality.equal mns (Just focusNs)) (sanitizeCppName local) (Strings.intercalate "::" (Lists.map sanitizeCppName (Strings.splitOn "." (Core.unName name))))) (\n -> n))+      in (Optionals.cases (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.intercalate "::" (Lists.map (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake) (Strings.splitOn "." (Packaging.unModuleName 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.cat2 (Names.localNameOf name) "PartialVisitor")+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.cat2 (Names.localNameOf tname) (Formatting.capitalize (Core.unName fname)))+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.cat2 (Names.localNameOf name) "Visitor")+visitorName name = sanitizeCppName (Strings.concat2 (Names.localNameOf name) "Visitor")

@@ -1,15 +1,21 @@ -- 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@@ -22,10 +28,13 @@ 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@@ -34,6 +43,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci+ -- | Convert an access specifier to an expression accessSpecifierToExpr :: Syntax.AccessSpecifier -> Ast.Expr accessSpecifierToExpr a =@@ -42,6 +52,7 @@       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 =@@ -52,6 +63,7 @@         additiveExpressionToExpr left,         (Serialization.cst "+"),         (multiplicativeExpressionToExpr right)])+ -- | Convert an additive expression to an expression additiveExpressionToExpr :: Syntax.AdditiveExpression -> Ast.Expr additiveExpressionToExpr e =@@ -59,18 +71,21 @@       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 =@@ -86,6 +101,7 @@       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 =@@ -95,6 +111,7 @@       in (Serialization.spaceSep [         accessSpecifierToExpr access,         (Serialization.cst name)])+ -- | Convert a basic type to an expression basicTypeToExpr :: Syntax.BasicType -> Ast.Expr basicTypeToExpr t =@@ -108,6 +125,7 @@       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 =@@ -118,6 +136,7 @@         andExpressionToExpr left,         (Serialization.cst "&"),         (equalityExpressionToExpr right)])+ -- | Convert a bitwise or operation to an expression bitwiseOrOperationToExpr :: Syntax.BitwiseOrOperation -> Ast.Expr bitwiseOrOperationToExpr op =@@ -128,6 +147,7 @@         inclusiveOrExpressionToExpr left,         (Serialization.cst "|"),         (exclusiveOrExpressionToExpr right)])+ -- | Convert a bitwise xor operation to an expression bitwiseXorOperationToExpr :: Syntax.BitwiseXorOperation -> Ast.Expr bitwiseXorOperationToExpr op =@@ -138,22 +158,26 @@         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.cat2 "&" name)) (Serialization.cst name))+      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 =@@ -162,6 +186,7 @@       Syntax.CaseStatementDefault v0 -> Serialization.spaceSep [         Serialization.cst "default:",         (statementToExpr v0)]+ -- | Convert a case value to an expression caseValueToExpr :: Syntax.CaseValue -> Ast.Expr caseValueToExpr cv =@@ -174,10 +199,12 @@           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 =@@ -186,9 +213,10 @@           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.cat [+      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 =@@ -197,6 +225,7 @@       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 =@@ -211,6 +240,7 @@         (Logic.ifElse (Lists.null 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 =@@ -221,6 +251,7 @@         expressionToExpr left,         (Serialization.cst ","),         (assignmentExpressionToExpr right)])+ -- | Convert a comment to an expression commentToExpr :: Syntax.Comment -> Ast.Expr commentToExpr c =@@ -228,16 +259,19 @@       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 =@@ -246,7 +280,7 @@           params = Syntax.constructorDeclarationParameters cd           inits = Syntax.constructorDeclarationInitializers cd           body = Syntax.constructorDeclarationBody cd-      in (Serialization.spaceSep (Optionals.cat [+      in (Serialization.spaceSep (Optionals.givens [         Just (Serialization.noSep [           Serialization.cst name,           (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]),@@ -254,6 +288,7 @@           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 =@@ -265,6 +300,7 @@       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 =@@ -280,6 +316,7 @@           Serialization.parenListAdaptive (Lists.map (\p -> Serialization.cst p) ps)])),         (Optionals.cases replacement [] (\r -> [           Serialization.cst r]))]))+ -- | Convert a destructor declaration to an expression destructorDeclarationToExpr :: Syntax.DestructorDeclaration -> Ast.Expr destructorDeclarationToExpr dd =@@ -292,11 +329,12 @@         Lists.map functionSpecifierPrefixToExpr prefixSpecs,         [           Serialization.noSep [-            Serialization.cst (Strings.cat2 "~" name),+            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 =@@ -307,6 +345,7 @@         multiplicativeExpressionToExpr left,         (Serialization.cst "/"),         (unaryExpressionToExpr right)])+ -- | Convert a do statement to an expression doStatementToExpr :: Syntax.DoStatement -> Ast.Expr doStatementToExpr ds =@@ -319,18 +358,22 @@         (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 =@@ -341,6 +384,7 @@         equalityExpressionToExpr left,         (Serialization.cst "=="),         (relationalExpressionToExpr right)])+ -- | Convert an equality expression to an expression equalityExpressionToExpr :: Syntax.EqualityExpression -> Ast.Expr equalityExpressionToExpr e =@@ -348,18 +392,21 @@       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 =@@ -371,12 +418,14 @@         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 =@@ -384,6 +433,7 @@       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 =@@ -402,6 +452,7 @@             (Serialization.cst ";"),             (expressionToExpr inc)]))],         (statementToExpr body)])+ -- | Convert a function application to an expression functionApplicationToExpr :: Syntax.FunctionApplication -> Ast.Expr functionApplicationToExpr fa =@@ -411,6 +462,7 @@       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 =@@ -419,6 +471,7 @@       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 =@@ -428,6 +481,7 @@       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 =@@ -448,12 +502,14 @@         (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 =@@ -462,6 +518,7 @@       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 =@@ -470,6 +527,7 @@       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 =@@ -479,6 +537,7 @@       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 =@@ -489,6 +548,7 @@         relationalExpressionToExpr left,         (Serialization.cst ">="),         (shiftExpressionToExpr right)])+ -- | Convert a greater-than operation to an expression greaterOperationToExpr :: Syntax.GreaterOperation -> Ast.Expr greaterOperationToExpr op =@@ -499,51 +559,58 @@         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.cat [+      in (Logic.ifElse isSystem (Serialization.cst (Strings.concat [         "#include <",         name,-        ">"])) (Serialization.cst (Strings.cat [+        ">"])) (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.showBigint v0)-      Syntax.IntegerLiteralHexadecimal v0 -> Serialization.cst (Strings.cat2 "0x" v0)-      Syntax.IntegerLiteralOctal v0 -> Serialization.cst (Strings.cat2 "0" v0)-      Syntax.IntegerLiteralBinary v0 -> Serialization.cst (Strings.cat2 "0b" 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 =@@ -552,6 +619,7 @@       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 =@@ -565,6 +633,7 @@       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 =@@ -572,8 +641,9 @@       let label = Syntax.labeledStatementLabel ls           stmt = Syntax.labeledStatementStatement ls       in (Serialization.newlineSep [-        Serialization.cst (Strings.cat2 label ":"),+        Serialization.cst (Strings.concat2 label ":"),         (statementToExpr stmt)])+ -- | Convert a lambda expression to an expression lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr lambdaExpressionToExpr le =@@ -589,6 +659,7 @@           Serialization.cst "->",           (typeExpressionToExpr t)])),         (compoundStatementToExpr body)])+ -- | Convert a left shift operation to an expression leftShiftOperationToExpr :: Syntax.LeftShiftOperation -> Ast.Expr leftShiftOperationToExpr op =@@ -599,6 +670,7 @@         shiftExpressionToExpr left,         (Serialization.cst "<<"),         (additiveExpressionToExpr right)])+ -- | Convert a less-than-or-equal operation to an expression lessEqualOperationToExpr :: Syntax.LessEqualOperation -> Ast.Expr lessEqualOperationToExpr op =@@ -609,6 +681,7 @@         relationalExpressionToExpr left,         (Serialization.cst "<="),         (shiftExpressionToExpr right)])+ -- | Convert a less-than operation to an expression lessOperationToExpr :: Syntax.LessOperation -> Ast.Expr lessOperationToExpr op =@@ -619,6 +692,7 @@         relationalExpressionToExpr left,         (Serialization.cst "<"),         (shiftExpressionToExpr right)])+ -- | Convert a line directive to an expression lineDirectiveToExpr :: Syntax.LineDirective -> Ast.Expr lineDirectiveToExpr ld =@@ -630,32 +704,35 @@           Serialization.cst "#line",           (Serialization.cst (Literals.showInt32 lineNumber))],         (Optionals.cases filename [] (\f -> [-          Serialization.cst (Strings.cat [+          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.showFloat64 (Syntax.unFloatingLiteral v0))-      Syntax.LiteralCharacter v0 -> Serialization.cst (Strings.cat [+      Syntax.LiteralCharacter v0 -> Serialization.cst (Strings.concat [         "'",         (Syntax.unCharacterLiteral v0),         "'"])-      Syntax.LiteralString v0 -> Serialization.cst (Strings.cat [+      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 =@@ -666,12 +743,14 @@         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 =@@ -682,6 +761,7 @@         logicalOrExpressionToExpr left,         (Serialization.cst "||"),         (logicalAndExpressionToExpr right)])+ -- | Convert a map entry to an expression mapEntryToExpr :: Syntax.MapEntry -> Ast.Expr mapEntryToExpr me =@@ -693,6 +773,7 @@           expressionToExpr key],         (Serialization.cst "->"),         (expressionToExpr val)])+ -- | Convert a map to an expression mapToExpr :: Syntax.Map -> Ast.Expr mapToExpr m =@@ -707,6 +788,7 @@           (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 =@@ -716,6 +798,7 @@       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 =@@ -726,6 +809,7 @@         postfixExpressionToExpr obj,         (Serialization.cst "."),         (Serialization.cst member)])+ -- | Convert a member declaration to an expression memberDeclarationToExpr :: Bool -> Syntax.MemberDeclaration -> Ast.Expr memberDeclarationToExpr commas m =@@ -736,6 +820,7 @@       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 =@@ -744,6 +829,7 @@         accessSpecifierToExpr v0,         (Serialization.cst ":")]       Syntax.MemberSpecificationMember v0 -> memberDeclarationToExpr commas v0+ -- | Convert a modulo operation to an expression moduloOperationToExpr :: Syntax.ModuloOperation -> Ast.Expr moduloOperationToExpr op =@@ -754,6 +840,7 @@         multiplicativeExpressionToExpr left,         (Serialization.cst "%"),         (unaryExpressionToExpr right)])+ -- | Convert a multiplicative expression to an expression multiplicativeExpressionToExpr :: Syntax.MultiplicativeExpression -> Ast.Expr multiplicativeExpressionToExpr e =@@ -762,6 +849,7 @@       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 =@@ -772,6 +860,7 @@         multiplicativeExpressionToExpr left,         (Serialization.cst "*"),         (unaryExpressionToExpr right)])+ -- | Convert a namespace declaration to an expression namespaceDeclarationToExpr :: Syntax.NamespaceDeclaration -> Ast.Expr namespaceDeclarationToExpr nd =@@ -779,8 +868,9 @@       let name = Syntax.namespaceDeclarationName nd           decls = Syntax.namespaceDeclarationDeclarations nd       in (Serialization.spaceSep [-        Serialization.cst (Strings.cat2 "namespace " name),+        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 =@@ -791,6 +881,7 @@         equalityExpressionToExpr left,         (Serialization.cst "!="),         (relationalExpressionToExpr right)])+ -- | Convert an optional to an expression optionalToExpr :: Syntax.Optional -> Ast.Expr optionalToExpr opt =@@ -803,12 +894,14 @@         (Serialization.cst ">"),         (Optionals.cases 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 =@@ -818,7 +911,7 @@           unnamed = Syntax.parameterUnnamed p           defaultVal = Syntax.parameterDefaultValue p           nameExpr =-                  Serialization.cst (Logic.ifElse unnamed (Strings.cat [+                  Serialization.cst (Logic.ifElse unnamed (Strings.concat [                     "/*",                     name,                     "*/"]) name)@@ -829,6 +922,7 @@         (Optionals.cases defaultVal [] (\expr -> [           Serialization.cst "=",           (expressionToExpr expr)]))]))+ -- | Convert a pattern match to an expression patternMatchToExpr :: Syntax.PatternMatch -> Ast.Expr patternMatchToExpr pm =@@ -840,6 +934,7 @@         (Serialization.parenListAdaptive [           visitorToExpr visitor,           (expressionToExpr variant)])])+ -- | Convert a pointer member access operation to an expression pointerMemberAccessOperationToExpr :: Syntax.PointerMemberAccessOperation -> Ast.Expr pointerMemberAccessOperationToExpr pmao =@@ -850,6 +945,7 @@         postfixExpressionToExpr ptr,         (Serialization.cst "->"),         (Serialization.cst member)])+ -- | Convert a postfix expression to an expression postfixExpressionToExpr :: Syntax.PostfixExpression -> Ast.Expr postfixExpressionToExpr e =@@ -866,9 +962,11 @@       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.cat2 "#pragma " (Syntax.pragmaDirectiveContent pd))+pragmaDirectiveToExpr pd = Serialization.cst (Strings.concat2 "#pragma " (Syntax.pragmaDirectiveContent pd))+ -- | Convert a preprocessor directive to an expression preprocessorDirectiveToExpr :: Syntax.PreprocessorDirective -> Ast.Expr preprocessorDirectiveToExpr d =@@ -886,6 +984,7 @@       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 =@@ -894,6 +993,7 @@       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 =@@ -902,20 +1002,22 @@           includes = Syntax.programIncludes prog           decls = Syntax.programDeclarations prog           separate = \sep -> \defs -> Logic.ifElse (Lists.null defs) Nothing (Just (sep defs))-      in (Serialization.doubleNewlineSep (Optionals.cat [+      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.cat [+      in (Serialization.cst (Strings.concat [         ns,         "::",         name]))+ -- | Convert a qualified type to an expression qualifiedTypeToExpr :: Syntax.QualifiedType -> Ast.Expr qualifiedTypeToExpr qt =@@ -935,6 +1037,7 @@         Syntax.TypeQualifierPointer -> Serialization.noSep [           typeExpressionToExpr baseType,           (Serialization.cst "*")]+ -- | Convert a range-for statement to an expression rangeForStatementToExpr :: Syntax.RangeForStatement -> Ast.Expr rangeForStatementToExpr rfs =@@ -952,6 +1055,7 @@             (Serialization.cst ":"),             (expressionToExpr range)]))],         (statementToExpr body)])+ -- | Convert a relational expression to an expression relationalExpressionToExpr :: Syntax.RelationalExpression -> Ast.Expr relationalExpressionToExpr e =@@ -961,6 +1065,7 @@       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 =@@ -971,6 +1076,7 @@         shiftExpressionToExpr left,         (Serialization.cst ">>"),         (additiveExpressionToExpr right)])+ -- | Convert a selection statement to an expression selectionStatementToExpr :: Syntax.SelectionStatement -> Ast.Expr selectionStatementToExpr ss =@@ -986,6 +1092,7 @@         (Optionals.cases elseBranch (Serialization.cst "") (\stmt -> Serialization.newlineSep [           Serialization.cst "else",           (statementToExpr stmt)]))])+ -- | Convert a set to an expression setToExpr :: Syntax.Set -> Ast.Expr setToExpr s =@@ -997,6 +1104,7 @@         (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 =@@ -1004,12 +1112,14 @@       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 =@@ -1022,6 +1132,7 @@       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 =@@ -1033,6 +1144,7 @@         (Serialization.cst "["),         (expressionToExpr index),         (Serialization.cst "]")])+ -- | Convert a subtract operation to an expression subtractOperationToExpr :: Syntax.SubtractOperation -> Ast.Expr subtractOperationToExpr op =@@ -1043,6 +1155,7 @@         additiveExpressionToExpr left,         (Serialization.cst "-"),         (multiplicativeExpressionToExpr right)])+ -- | Convert a switch statement to an expression switchStatementToExpr :: Syntax.SwitchStatement -> Ast.Expr switchStatementToExpr ss =@@ -1053,12 +1166,14 @@         Serialization.cst "switch",         (Serialization.parens (expressionToExpr value)),         (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map caseStatementToExpr cases)))])+ -- | 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 =@@ -1072,6 +1187,7 @@           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 =@@ -1083,6 +1199,7 @@         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 =@@ -1092,6 +1209,7 @@       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 =@@ -1105,13 +1223,15 @@         (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.cat [+    Logic.ifElse isMultiline (Strings.concat [       "/* ",       s,-      " */"]) (Logic.ifElse (Equality.equal s "") "//" (Strings.cat2 "// " s))+      " */"]) (Logic.ifElse (Equality.equal s "") "//" (Strings.concat2 "// " s))+ -- | Convert a type expression to an expression typeExpressionToExpr :: Syntax.TypeExpression -> Ast.Expr typeExpressionToExpr t =@@ -1121,6 +1241,7 @@       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 =@@ -1129,12 +1250,13 @@           typ = Syntax.typedefDeclarationType td           isUsing = Syntax.typedefDeclarationIsUsing td       in (Logic.ifElse isUsing (Serialization.withSemi (Serialization.spaceSep [-        Serialization.cst (Strings.cat2 "using " name),+        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 =@@ -1142,6 +1264,7 @@       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 =@@ -1151,6 +1274,7 @@       in (Serialization.spaceSep [         unaryOperatorToExpr op,         (unaryExpressionToExpr operand)])+ -- | Convert a unary operator to an expression unaryOperatorToExpr :: Syntax.UnaryOperator -> Ast.Expr unaryOperatorToExpr op =@@ -1163,12 +1287,14 @@       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 =@@ -1187,6 +1313,7 @@         (Optionals.cases init [] (\expr -> [           Serialization.cst "=",           (expressionToExpr expr)]))])))+ -- | Convert a vector to an expression vectorToExpr :: Syntax.Vector -> Ast.Expr vectorToExpr v =@@ -1198,18 +1325,21 @@         (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 =

@@ -1,1253 +1,2032 @@ -- 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, map, pure, sum)-import qualified Data.Scientific as Sci-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"-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"-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"-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"-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"-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"-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"-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"-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"-data PragmaDirective =-  PragmaDirective {-    pragmaDirectiveContent :: String}-  deriving (Eq, Ord, Read, Show)-_PragmaDirective = Core.Name "hydra.cpp.syntax.PragmaDirective"-_PragmaDirective_content = Core.Name "content"-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"-data UndefDirective =-  UndefDirective {-    undefDirectiveName :: String}-  deriving (Eq, Ord, Read, Show)-_UndefDirective = Core.Name "hydra.cpp.syntax.UndefDirective"-_UndefDirective_name = Core.Name "name"-data IfdefDirective =-  IfdefDirective {-    ifdefDirectiveIdentifier :: String}-  deriving (Eq, Ord, Read, Show)-_IfdefDirective = Core.Name "hydra.cpp.syntax.IfdefDirective"-_IfdefDirective_identifier = Core.Name "identifier"-data IfndefDirective =-  IfndefDirective {-    ifndefDirectiveIdentifier :: String}-  deriving (Eq, Ord, Read, Show)-_IfndefDirective = Core.Name "hydra.cpp.syntax.IfndefDirective"-_IfndefDirective_identifier = Core.Name "identifier"-data IfDirective =-  IfDirective {-    ifDirectiveCondition :: String}-  deriving (Eq, Ord, Read, Show)-_IfDirective = Core.Name "hydra.cpp.syntax.IfDirective"-_IfDirective_condition = Core.Name "condition"-data ElifDirective =-  ElifDirective {-    elifDirectiveCondition :: String}-  deriving (Eq, Ord, Read, Show)-_ElifDirective = Core.Name "hydra.cpp.syntax.ElifDirective"-_ElifDirective_condition = Core.Name "condition"-type ElseDirective = ()-_ElseDirective = Core.Name "hydra.cpp.syntax.ElseDirective"-type EndifDirective = ()-_EndifDirective = Core.Name "hydra.cpp.syntax.EndifDirective"-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"-data ErrorDirective =-  ErrorDirective {-    errorDirectiveMessage :: String}-  deriving (Eq, Ord, Read, Show)-_ErrorDirective = Core.Name "hydra.cpp.syntax.ErrorDirective"-_ErrorDirective_message = Core.Name "message"-data WarningDirective =-  WarningDirective {-    warningDirectiveMessage :: String}-  deriving (Eq, Ord, Read, Show)-_WarningDirective = Core.Name "hydra.cpp.syntax.WarningDirective"-_WarningDirective_message = Core.Name "message"-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"-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"-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"-newtype ClassBody =-  ClassBody {-    unClassBody :: [MemberSpecification]}-  deriving (Eq, Ord, Read, Show)-_ClassBody = Core.Name "hydra.cpp.syntax.ClassBody"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-newtype SizeofExpression =-  SizeofExpression {-    unSizeofExpression :: TypeExpression}-  deriving (Eq, Ord, Read, Show)-_SizeofExpression = Core.Name "hydra.cpp.syntax.SizeofExpression"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-newtype OverloadedLambdas =-  OverloadedLambdas {-    unOverloadedLambdas :: [LambdaExpression]}-  deriving (Eq, Ord, Read, Show)-_OverloadedLambdas = Core.Name "hydra.cpp.syntax.OverloadedLambdas"-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"-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"-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"-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"-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"-newtype CompoundStatement =-  CompoundStatement {-    unCompoundStatement :: [Statement]}-  deriving (Eq, Ord, Read, Show)-_CompoundStatement = Core.Name "hydra.cpp.syntax.CompoundStatement"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-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"-newtype ExpressionStatement =-  ExpressionStatement {-    unExpressionStatement :: Expression}-  deriving (Eq, Ord, Read, Show)-_ExpressionStatement = Core.Name "hydra.cpp.syntax.ExpressionStatement"-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"-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"-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"-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"-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"-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"-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"-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"-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"-newtype FloatingLiteral =-  FloatingLiteral {-    unFloatingLiteral :: Double}-  deriving (Eq, Ord, Read, Show)-_FloatingLiteral = Core.Name "hydra.cpp.syntax.FloatingLiteral"-newtype CharacterLiteral =-  CharacterLiteral {-    unCharacterLiteral :: String}-  deriving (Eq, Ord, Read, Show)-_CharacterLiteral = Core.Name "hydra.cpp.syntax.CharacterLiteral"-newtype StringLiteral =-  StringLiteral {-    unStringLiteral :: String}-  deriving (Eq, Ord, Read, Show)-_StringLiteral = Core.Name "hydra.cpp.syntax.StringLiteral"-newtype BooleanLiteral =-  BooleanLiteral {-    unBooleanLiteral :: Bool}-  deriving (Eq, Ord, Read, Show)-_BooleanLiteral = Core.Name "hydra.cpp.syntax.BooleanLiteral"-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"-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"-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"-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"-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"-type Identifier = String-_Identifier = Core.Name "hydra.cpp.syntax.Identifier"-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"-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++ 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, map, pure, sum)+import qualified Data.Scientific as Sci++-- | 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<Args...>(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<int>)+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"