hydra-rdf (empty) → 0.17.0

raw patch · 15 files changed

+7380/−0 lines, 15 filesdep +basedep +containersdep +hydra-kernel

Dependencies added: base, containers, hydra-kernel, scientific

Files

• CHANGELOG.md +1372/−0
• LICENSE +201/−0
• NOTICE +3/−0
• hydra-rdf.cabal +50/−0
• src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs +706/−0
• src/main/haskell/Hydra/Dsl/Shacl/Model.hs +1735/−0
• src/main/haskell/Hydra/Owl/Syntax.hs +818/−0
• src/main/haskell/Hydra/Rdf/Serde.hs +140/−0
• src/main/haskell/Hydra/Rdf/Syntax.hs +132/−0
• src/main/haskell/Hydra/Rdf/Utils.hs +170/−0
• src/main/haskell/Hydra/Shacl/Coder.hs +317/−0
• src/main/haskell/Hydra/Shacl/Language.hs +79/−0
• src/main/haskell/Hydra/Shacl/Model.hs +260/−0
• src/main/haskell/Hydra/Shex/Syntax.hs +1068/−0
• src/main/haskell/Hydra/Xml/Schema.hs +329/−0

@@ -0,0 +1,1372 @@+# Hydra changelog++All notable changes to the Hydra project are documented in this file.++This changelog tracks changes across all Hydra implementations+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)+and supporting infrastructure.++The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).++Pre-1.0 versions are listed below.+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;+they are documented here for completeness.++---++## [0.17.0] - 2026-07-01++Major themes: first-class support for effects and I/O in the kernel, TypeScript and+Scala reaching publishable parity with the other hosts, and continued maturation of+the published-host build model.++### Highlights++- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286),+  [#288](https://github.com/CategoricalData/hydra/issues/288),+  [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant+  on `hydra.core.Type` for representing effectful computations; new kernel modules+  `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time`+  (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`,+  `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new+  `EffectfulTestCase` mechanism so the common test suite can exercise effectful+  primitives across hosts.+- **TypeScript is a complete implementation**+  ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes+  the common test suite, with a per-package npm publish pipeline+  ([#492](https://github.com/CategoricalData/hydra/issues/492)).+- **Scala publishing**: per-package Maven Central publish infrastructure+  ([#491](https://github.com/CategoricalData/hydra/issues/491)).+- **Published-host build model**: published mode now compiles the kernel from the+  co-generated `dist/haskell` rather than Hackage, removing the need for a+  `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500));+  the oil-and-water principle and cold-build workflow for `dist/haskell` are documented+  ([#376](https://github.com/CategoricalData/hydra/issues/376)).+- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel`+  (numeric suffixes) in `hydra.names`+  ([#436](https://github.com/CategoricalData/hydra/issues/436)).++### Implementations++Eight hosts self-host and pass the common test suite across five families: Haskell,+Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs+Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud"+(the coder still has emission bugs and the head's runtime is largely placeholder; it+does not yet host the test suite).++### New Features++- Translingual cross-reference convention for `doc` strings: doc-escape tags render to+  each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc)+  ([#433](https://github.com/CategoricalData/hydra/issues/433)).+- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and+  TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)).++### Improvements++- The Java/Maven publish set now covers every official Hydra target language, one coder+  package per implementation family+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).+- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and+  `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets+  never collide on coordinates+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).+- Host-specific third-party integrations (the former `bindings/` tree) are folded into+  `overlay/`, unifying hand-written host-native source under one tree+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).+- The coder de-parameterizes context and error types, simplifying generated coder+  signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)).+- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace+  interfaces (`Maps`, `Strings`, etc.)+  ([#499](https://github.com/CategoricalData/hydra/issues/499)).++---++## [0.16.1] - 2026-06-16++Major themes: the first release built by bootstrapping from previously published+packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and+published-package self-containment fixes for the artifacts that bootstrap rests on.++### Highlights++- **Bootstrap from published packages**: the build links the published 0.16.0 hosts+  (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra,+  resting on 0.16.0's forward-compatibility guarantees — the published-host consume+  model with a `--local-host` shim, used for the first time in a release+  ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds+  against **local** Haskell and Python hosts (`hostOverrides`), because the published+  0.16.0 artifacts it would otherwise consume are the very ones being repaired below.+- **First full 9 × 9 bootstrapping sweep** — every implementation generating every+  other; dozens of cross-host issues surfaced and fixed+  ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing).+- **Published-package self-containment**: relocate each host's hand-written runtime+  into `overlay/<lang>/hydra-kernel/` so it ships inside the published `hydra-kernel`+  artifact — Python `hydra.python.util` into the wheel+  ([#461](https://github.com/CategoricalData/hydra/issues/461),+  [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell+  authoring DSL + `Libraries`/`Terms` into the sdist+  ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a+  uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive+  names are derived from generated `PrimitiveDefinition` def-modules rather than+  hand-written name strings, in every host+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).+- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules+  are synthesized at build time and excluded from `dist/`, with the synthesizer (not+  inference) as the authority for their annotations+  ([#448](https://github.com/CategoricalData/hydra/issues/448),+  [#476](https://github.com/CategoricalData/hydra/issues/476)).+- **Release hardening**: Apache source-release compliance (signed source archive,+  LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)),+  per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)),+  and packaging-boundary verification gated in CI and at publish time+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).++### New features++- Published-host consume model wired through `bin/sync.sh` for all three hosts+  (`--published-host` default, `--local-host` shim), with the version basis keyed+  off `hydra.json` and the `VERSION` file retired+  ([#370](https://github.com/CategoricalData/hydra/issues/370),+  [#347](https://github.com/CategoricalData/hydra/issues/347)).+- Java and Python coder DSL sources made the sole source of truth; the legacy+  Haskell DSL copies were deleted and cross-package references resolve by name+  ([#346](https://github.com/CategoricalData/hydra/issues/346)).+- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the+  per-package trio and `stack build`s it; Python installs the wheels into an+  isolated venv and imports the kernel modules; Java resolves the published jars+  from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh`+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).+- Apache-compliant canonical source archive: signed + checksummed `git archive`+  tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI+  workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)).+- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with+  dependency-closure and leaves-first ordering checks+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).+- `hydra-typescript` published as a target Java/Maven + PyPI artifact+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).+- Java coder emits a fluent builder for every generated record type+  ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits+  per-field `with_<field>` copy-update methods and a fluent builder+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).++### Improvements++- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation`+  carrier across all hosts; add a graph-free `funT` coder and six `lists` default+  implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)).+- Derive package routing from declared modules; split derived generation into broad+  `mainDslModules` and scoped `mainEncodingModules`+  ([#474](https://github.com/CategoricalData/hydra/issues/474),+  [#475](https://github.com/CategoricalData/hydra/issues/475)).+- Hash JSON content into the per-package input digest; add `digest-check+  refresh-input` and a CI guard that force-regenerates and diffs+  `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)).+- Per-package inference seeds downstream packages from each package's full universe+  while inferring only write targets, fixing `hydra-scala` inference within the CI+  heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold+  ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)).+- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules`+  manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)).+- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels+  (`dist-info`); declare Apache-2.0 in the Scala build+  ([#441](https://github.com/CategoricalData/hydra/issues/441)).+- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager+  coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453),+  [#477](https://github.com/CategoricalData/hydra/issues/477),+  [#425](https://github.com/CategoricalData/hydra/issues/425)).+- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main`+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).++### Bug fixes++- **Python wheel self-containment**: the `hydra-kernel` wheel now ships+  `hydra.python.util`; gated by a packaging-boundary smoke test in CI and+  `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472),+  [#461](https://github.com/CategoricalData/hydra/issues/461)).+- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs`+  (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold+  build of the published `hydra-kernel`+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).+- Decode synthesizer threads the fully-applied result type into wrap/record/union+  decoder bodies, so derived decoders emit `DataRow<v>` rather than raw `DataRow`,+  fixing Java and Scala generic decode compilation+  ([#476](https://github.com/CategoricalData/hydra/issues/476)).+- Scala coder emits explicit type arguments for polymorphic non-primitive+  references under a type application (e.g. `requireField`), fixing `Any`-inference+  of curried decoder lambda parameters in `decode/typed`+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path+  so it no longer collides with the generated `hydra.lib.*` def-modules+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- Python coder uses the binding `TypeScheme` as the authoritative source for+  parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488));+  fixes a duplicate `self` parameter in builders+  ([#478](https://github.com/CategoricalData/hydra/issues/478)).+- Sort term definitions by name in source-file generation so non-Haskell hosts emit+  deterministic alphabetical Haskell output (host-independent of `Maps.elems`+  iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)).+- Java coder serializes the `static` method modifier (previously a non-exhaustive+  case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc+  `@link`/`@param` sanitization for strict doclint+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).+- Scala host writer appends a trailing newline when missing, fixing a Lisp-target+  byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)).+- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel+  contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order+  and `--kernel-only` filter fixes after kernel renames+  ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the+  `hydra-haskell` baseline for Clojure→Haskell rebuilds+  ([#487](https://github.com/CategoricalData/hydra/issues/487),+  [#460](https://github.com/CategoricalData/hydra/issues/460)).+- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists+  rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452),+  also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read+  module names via the correct struct accessor+  ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale+  surplus flag arguments from `generate-source-files` calls+  ([#457](https://github.com/CategoricalData/hydra/issues/457),+  [#458](https://github.com/CategoricalData/hydra/issues/458),+  [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped+  projection/unwrap parameters to avoid kernel shadowing+  ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a+  non-zero exit from the Scheme test runner on failures and fix Scheme float+  scientific-notation formatting for `|x| >= 1e7`+  ([#447](https://github.com/CategoricalData/hydra/issues/447)).+- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and+  TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482),+  [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host+  target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5),+  [#7](https://github.com/CategoricalData/hydra/issues/7),+  [#17](https://github.com/CategoricalData/hydra/issues/17)).+- TypeScript test runtime reads the kernel JSON field names `body`/`signature`+  (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON+  ([#485](https://github.com/CategoricalData/hydra/issues/485)).+- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal+  partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480));+  persist the run dir on bootstrap prep-phase failures+  ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host+  static deps so the bootstrap demo finds fresh dist+  ([#445](https://github.com/CategoricalData/hydra/issues/445)).+- Pin the Python target test interpreter to Python ≥ 3.12+  ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme+  target test-runner re-copy robustness+  ([#456](https://github.com/CategoricalData/hydra/issues/456)).+- JavaDoc Pages publish rewritten to build a combined site from the CI-generated+  `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a+  bare checkout with no `dist/java/` present+  ([#450](https://github.com/CategoricalData/hydra/issues/450)).++### Documentation++- Document the `overlay/` self-containment model, the published-host consume model+  for all three hosts, the `hydra.json` version / host-version basis, and a+  migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434),+  [#370](https://github.com/CategoricalData/hydra/issues/370),+  [#347](https://github.com/CategoricalData/hydra/issues/347)).+- Document the kernel self-containment / `hydra.lib.*` def-module model and the+  derived-module no-inference invariant+  ([#473](https://github.com/CategoricalData/hydra/issues/473),+  [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and+  Python record builders documented in the DSL guides+  ([#465](https://github.com/CategoricalData/hydra/issues/465),+  [#466](https://github.com/CategoricalData/hydra/issues/466)).+- Use absolute GitHub URLs in package READMEs so links resolve when published+  standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a+  README into each Python package dir for sdist metadata+  ([#418](https://github.com/CategoricalData/hydra/issues/418)).++---++## [0.16.0] - 2026-06-09++Major themes: primitive-metadata reification, self-hosting coder DSLs with all+eight hosts passing the common test suite, finalized `hydra.packaging`, and a+deep kernel-vocabulary cleanup.++### Highlights++- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).++### New features++- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).++### Improvements++- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).++### Bug fixes++- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).++### Removed++- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).+  Arbitrary-precision floating-point values were inconsistently supported+  across host languages (Java/Scala in particular lacked a true IEEE 754+  arbitrary-precision implementation), and nothing in the codebase relied on+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)+  replace the removed bigfloat-routed conversions.+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era+  bridge that flattened the multi-source-dir Haskell head into one self-contained+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).++### Documentation++- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and+  in-source kernel comments.+- New `docs/json-format.md` reference describing the canonical JSON wire format+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer+  threshold).+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`+  (HM type inference with class constraints).+- Cross-checked every prose doc against current code; corrected drift in+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,+  and the build-system narrative.+- Wove motivation ("the why") through the existing doc surface rather than+  collecting it into separately-titled sidebars; landed an inference-overview+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).+- Aligned doc vocabulary with the LambdaGraph paper and the literature review+  for the design space Hydra inhabits.+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`+  now carries a canonical packages table.+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by+  violation frequency; `claude/pitfalls.md` superseded entries folded into+  `docs/troubleshooting.md` / recipes.+- Project-descriptor strings reviewed and aligned across 24 build / packaging+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge+  classifiers, Hydra-format `package.json` files).+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub+  repo, plus the full published-artifact list across Hackage, Maven Central,+  PyPI, and conda-forge.+- In-source kernel-code rationale comments added at key Sources sites covering+  injection / pair / either / unit-void duality, error taxonomy, variant+  records, inference-context threading, validation profiles, reduction state,+  lexical filters, name mangling, scoping, variable handling, defaults+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules+  cross-reference `docs/json-format.md`.+- Filed `Primitive.implementation` carrier-simplification follow-up+  ([#446](https://github.com/CategoricalData/hydra/issues/446))+  to drop the unused `InferenceContext` and `Graph` parameters once the+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))+  lands.++---++## [0.15.0] - 2026-04-29++A structural-cleanup release.+The repository is reorganized into a three-tree+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge+([#305](https://github.com/CategoricalData/hydra/issues/305)).+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.++### Highlights++- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).++### New features++- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).+- User-defined-function (UDF) support and DSL-vs-primitive overrides+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).++### Improvements++- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).++### Bug fixes++- `substInTypeScheme` capture-unsafe substitution under nested forall binders.+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).++### Documentation++- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,+  READMEs, recipes, demos, and seven wiki pages updated.+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated+  detection, design-violation checks, and freshness checks.+- Documentation style guide added at `docs/documentation-style-guide.md`.+- Cross-worktree messaging protocol documented in CLAUDE.md.+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).++---++## [0.14.1] - 2026-03-30++Patch release.+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.++### Improvements++- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.++### Bug fixes++- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.++---++## [0.14.0] - 2026-03-29++Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.++### Highlights++- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as+  bootstrapping hosts.+  The four Lisp dialects share a single coder and serializer.+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures+  and IEEE 754 float precision fixes.++### Breaking changes++- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).++### New features++- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).++### Improvements++- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).++### Release tooling++- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).++### Documentation++- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).+- Coding style guide added to wiki.+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).++---++## [0.13.0] - 2026-02-27++Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations+and demonstrating mutual self-hosting across all three languages.+Significant improvements to type inference, type checking, rewriting, and adaptation.+New language features include first-class Either types, typeclass inference, binary data support,+and a native JSON parser/writer.+Comprehensive tooling for cross-implementation bootstrapping+and provisional support for Go, Rust, and JavaScript targets.++### Highlights++- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination+  of host and target language (9 paths total).+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python+  coders are now defined as Hydra DSL modules, making them self-hosting.+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation+  code generation.++### Breaking changes++- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.+- Renamed `hydra.json` to `hydra.json.model`.+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.+- Removed deprecated `hydra.decoding` module.+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).+- Removed `hydra.lib.tuples` library.+- Removed C# coder stub (C# syntax model remains).+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).++### New features++- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).+- New bootstrapping demo validating all 9 paths across 249 modules.+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation+  code generation.+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;+  cross-checked via a special test runner.+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):+  type schemes with typeclass constraints via `TypeVariableMetadata`;+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable+  across all three implementations; legacy `requiresInterp` tag removed.+- Let hoisting and flattening: hoisting polymorphic let terms;+  refined hoisting for monomorphic bindings inside polymorphic ones;+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- New primitives:+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).+- DeepCore DSL: a layer one level deeper than the Meta DSLs,+  for programs that construct programs that construct terms.+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).++### Improvements++- Type system:+  - Refactored `hydra.inference` to create new module `hydra.checking`.+  - Inference checks after unification to prevent schema names from being unified+    with inferred type variables.+  - Type application terms preserved when preparing application terms for Python.+  - Sanity-check tuple projection index against arity during inference.+  - Bind lost type variables in term annotations.+  - Made `extendTypeContextForLet` tolerant of untyped bindings.+- Code generation:+  - Python: support for deeply-nested match statements; more complete `let` support;+    Pythonic syntax for polymorphic function definitions; refinements for complex+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).+  - Java: method declaration style consistent with calling style.+  - Haskell: standardized typeclass names.+  - Increased maximum trace depth to support more complex sources.+- Common test suite promotion: all tests promoted into a shared, implementation-independent+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).+- Reorganized Haskell DSL definitions; standardized imports.+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.+- Lexical helper for dereferencing schema types through aliases.+- Made JSON parser lazy with new `lazy` parser combinator.+- More efficient substitution helpers for empty substitutions.+- Precomputed type/inference context in kernel test runner for performance.+- Property graph encoding and decoding modules promoted into DSL.+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.+- `hydra.show.*` modules generated into Java and Python.+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;+  Java generation; finalized output format.+- Testing: extended test runners for let hoisting (Haskell, Python, Java);+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).++### Bug fixes++- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).+- Fixed bug in type checking in connection with dead code.+- Fixed bug in `removeTypesFromTerm`.+- Fixed bug in `typeOfMap`.+- Fixed 32-bit max int value in `hydra.constants`.+- Fixed numeric precision in Python.+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.+- Fixed Haskell coder with respect to imports for binary literals.+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell+  due to name collisions.+- Fixed consistency issues in Python primitives:+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.+- Fixed Haskell type signature of `hydra.lists.span`.+- Fixed issue with eta expansion of typed terms.+- Fixed shadowing issue in generated encoding modules.+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Documentation++- Updated main README with complete implementation status.+- Added Documentation sections to all implementation READMEs.+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).+- Fixed incorrect code paths in Implementation.md.+- Added Java section to Testing wiki.+- Comprehensive developer recipes in `docs/recipes/`.+- Documentation for tail-call optimization implementation.+- Added Haddock comments to Haskell primitives.+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).++### Community++- Accepted babeloff's `isTrivialTerm` changes.++---++## [0.12.0] - 2025-08-28++A consolidation release: significant Python progress, kernel-level cleanup,+and a wave of bookkeeping closures for Hydra-Java module ports.++### Breaking changes++- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).++### New features++- Significant progress toward Hydra-Python completion:+  generated all kernel types and terms into Python;+  added `Decimal` support for bigfloat values;+  environment tracking for variable scoping;+  generated `hydra.languages` into Python;+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).++### Improvements++- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Improved adapter solution with respect to literals.+- Better handling of type variables in Python coder.+- Enhanced term-level Python generation with proper ordering to minimize forward references.+- Topo-sort helper function for dependency management.+- Updated all Python libraries with latest changes.+- Distinguished between deannotation and detyping of terms.+- Adapted primitives when applying language constraints to a graph.+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).++### Bug fixes++- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Corrected handling of variable references in Python application terms.+- Fixed nullary functions in Python (added empty parens).+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Bookkeeping++- Closed long-standing Hydra-Java module-port issues+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));+  most of the underlying work shipped in earlier releases.+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).++### Documentation++- Updated Hydra-Haskell README.+- Updated Hydra-Java README with corrected links.+- Updated JavaDocs.++---++## [0.11.0] - 2025-03-16++Untagged in-repository version.+A type-inference rebase release: major restructuring of inference internals+to align with Algorithm W, plus a sweeping removal of explicit type annotations+across the kernel.++### Highlights++- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- **`hydra.inference` module** introduced for inference type definitions;+  substitution and unification moved up a level.++### Breaking changes++- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).++### New features++- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));+  added "kernel examples" inference tests; more recursion / mutual recursion cases.++### Improvements++- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).+- `hydra.core.Unit` recognized by the Haskell coder.+- Refactored inference tests.++### Bug fixes++- Fix for underdetermined type in `hydra.decode`.++---++## [0.10.0] - 2025-02-19++Untagged in-repository version.+Adds Hydra-Python (initial completion), a GraphSON coder,+provisional Hydra-Go support, and dot-separated namespace conventions.++### Highlights++- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel+  modules in Python, and full library implementations across kernel namespaces.+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### Breaking changes++- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### New features++- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,+  `hydra.literals` and other kernel modules in Python; tuple-expression support;+  updated `hydra.constants` in Python.+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).++### Improvements++- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.++---++## [0.9.0] - 2025-01-06++Untagged in-repository version.+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.++### Highlights++- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- **Python coder scaffold**: serde, language constraints, and generated Haskell+  sources for Python.+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).++### New features++- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- Python coder scaffold and serde.+- Provisional Python language constraints module.+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.+- New `hydra.coders` DSL.+- New DSL functions for core variants.++### Improvements++- Generalized `Namespaces` so it can be used for languages other than Haskell.+- Local-name-only Python type aliases (the directory tree provides the namespace).+- Coders DSL used to simplify Java language-constraint sources.+- Removed redundant productions in the Python grammar.+- Added unit tests for fluent flows.++### Documentation++- Updated JavaDocs for 0.9.0.++---++## [0.8.1] - 2024-09-24++Patch release.++### Improvements++- Generalized the property graph merging utility to accept type systems other than Hydra Core.++---++## [0.8.0] - 2024-09-09++C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java+to support Spark.++### Breaking changes++- Made `FlowException` serializable for Spark support (may affect existing error handling).++### New features++- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):+  full support for lambdas and recursive `let` statements;+  compact 'accessor graph' visualization option;+  customizable label styles;+  highlighted let-bound terms; edge labels.+- Term accessor type to facilitate lenses and path-aware transformations.+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).++### Improvements++- Added `</>` as alternative to `@@` application operator in Haskell DSLs.+- Utilities for working with term accessors.+- More specific exception class for JSON decoding.+- Additional convenience methods on `JsonDecoding.java`.+- Used transitive dependencies in hydra-java and hydra-ext.+- Upgraded ANTLR to address a vulnerability.+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.++---++## [0.7.0] - 2024-08-21++Major refactoring of module organization and namespace management.+Establishes the DNS-style namespace convention in hydra-ext+and lifts property-graph models into a top-level `hydra/pg` namespace.++### Breaking changes++- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.+- Property graphs: promoted property graph modules from+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.+- Project structure: renamed `hydra-extensions` to `hydra-ext`;+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));+  made hydra-ext into a Gradle subproject alongside hydra-java;+  added top-level Gradle build.++### Improvements++- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.+- Moved KQL, Parquet, and Python modules to hydra-ext.+- Separated JavaDocs for hydra-java and hydra-ext.+- Updated publishing configuration in `build.gradle`.++---++## [0.6.0] - 2024-08-19++Type-system improvements (System F type abstraction/application; eliminated polymorphic+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java+field-name constants), and revamped annotation handling.++### Breaking changes++- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).++### New features++- System F support: `typeAbstraction` and `typeApplication` term constructors.+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.++### Improvements++- Primitive organization: Hydra primitives organized into libraries for namespace management.+- Code generation:+  - Escaped field name constants and `with_` methods in Java coder.+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).+  - Avoided duplicated comments in wrapper classes in generated Java.+  - Removed superfluous newtype comments in Haskell coder.+- Updated Delta Parquet model to follow the Java API more closely.+- Enriched OpenCypher features module with the complete list of standard Cypher functions.+- Added convenience methods to `JsonEncoding.java`.+- Restored `Hydra.Inference` subdirectory.+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).++### Bug fixes++- Fixed handling of type annotations in term adapters.+- Fixed decoding of encoded terms annotated with a type.+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).++---++## [0.5.3] - 2024-08-06++Patch release.+Preserves order of map key/value pairs and set elements during JSON serialization.++### Bug fixes++- Preserved ordering of key/value pairs and set elements in JSON output.++### New features++- Polymorphic `equal` primitive in Haskell and Java.+- Generated Hydra type definitions together with native instantiations of Hydra types+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).++---++## [0.5.1] - 2024-08-01++Patch release.+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.++### Improvements++- Updated dependencies.++---++## [0.5.0] - 2024-07-26++Untagged in-repository version.+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.++### Breaking changes++- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Revamped core encoding and `Let`: bindings are now a list of+  `(name, term, optional type scheme)` triplets instead of a map.+- Unified typed-term types and moved `TypeScheme` into Hydra Core.+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`+  type from `hydra/phantoms`.+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).++### New features++- `LiteralTypes` DSL module so literals can be built independently of terms.+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.+- `TypeConstraint` type added to the kernel.+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in+  list elimination term by default.++### Improvements++- Improvements to Java and JSON coders; improved untyped JSON coder.+- Pre-order and post-order term-traversal test cases added.+- Refactored type inference tests.+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).++---++## [0.4.0] - 2024-07-10++Untagged in-repository version.+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),+the Gremlin model, and Protobuf annotation refinements.++### Breaking changes++- Null checks added to constructors and `withXXX()` methods in generated Java;+  null values are no longer permitted in Hydra-Java.+- Removed Java 8 restriction (raised minimum Java version).++### New features++- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.+- Java options in generated Protobuf.++### Improvements++- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.+- Added 'automatically generated file' disclaimer to generated Java files.+- Added autogen comments and null checks to (most) generated Java.+- Added necessary schema-level dependencies for built-in modules.+- Added null checks to the Flows DSL in Java.++---++## [0.3.0] - 2024-06-05++Untagged in-repository version.+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),+a KQL (Kusto Query Language) model and serializer,+a Delta Parquet model,+and an early property graph queries model in the style of Cypher.++### New features++- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));+  ANTLR added as a build dependency;+  large Cypher test suite drawn from the Cypher Manual.+- Cypher-to-PG-query transformer (Java; partially implemented).+- Property graph queries DSL and generated property graph query classes in Java.+- Property graph queries model (Cypher / future GQL style).+- KQL (Kusto Query Language) initial model and basic serializer.+- Delta Parquet model with generated sources.++### Improvements++- Java options and `deprecated=true` support in generated Protobuf.+- Convenience methods in Java.++---++## [0.2.0] - 2024-01-10++Hydra-Java 0.2.0 release.+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),+Cypher unification, and the start of the typed-DSL story in Haskell.++### New features++- Property graph validation: validator type, optionality on property types,+  customizable id/property handling in the merging adapter, fine-tuned validation,+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,+  Java options, non-string options.+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;+  `fromFlow` variants including one that throws.++### Improvements++- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).+- Code quality:+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).+  - Extended line-length limit from 100 to 120 characters.+  - Disabled overly restrictive indentation and import-order rules.+  - Disabled `RightCurlyAlone` for compact inline map definitions.+- Streamlined property-graph element merging to unify properties with identical+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Convenience functions for printing literals and literal types in the Java DSL.+- Minor addition to JSON decoding.+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).++### Bug fixes++- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).+- Various minor fixes during the Java module ports.++---++## [0.1.1] - 2022-12-04++Patch release the same day as 0.1.0.+README polish only.++---++## [0.1.0] - 2022-12-04++First packaged release of Hydra (Hackage).+This release contains the complete foundation of Hydra.++### Core language++- Hydra's core type and data languages (`hydra.core`).+- Core models for graphs and modules.+- Computation model with the `Flow` monad.+- BNF grammars support.+- Phantom types.+- Basic operations on types and terms.++### Type system++- Hindley–Milner-style type inference.+- Type schemes with polymorphism.+- Type/term validation.++### Transformations++- Adapter system: type-to-type rewriting and transformation.+- Coders:+  Haskell coder (types and terms),+  Java coder (types and terms),+  partial Scala coder (terms only),+  Avro coder,+  JSON coder,+  PDL (Pegasus Data Language) coder,+  RDF + SHACL coder,+  YAML coder.++### Language support++- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),+  and TinkerPop-style property graphs.++### Developer tools++- Type-construction DSL and term-construction DSL.+- QuickCheck property-based tests.++### Implementations++- Hydra-Haskell: bootstrapping implementation with full kernel.+- Hydra-Java: Java implementation with mature tooling.++### Community++- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).++---++## Contributing++We welcome contributions! Please see:++- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)+- [LambdaGraph Discord](https://bit.ly/lg-discord)++## Release process++See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)+wiki page and [docs/release-workflow.md](docs/release-workflow.md)+for information on how Hydra releases are versioned, built, and published.

@@ -0,0 +1,201 @@+                                 Apache License+                           Version 2.0, January 2004+                        http://www.apache.org/licenses/++   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++   1. Definitions.++      "License" shall mean the terms and conditions for use, reproduction,+      and distribution as defined by Sections 1 through 9 of this document.++      "Licensor" shall mean the copyright owner or entity authorized by+      the copyright owner that is granting the License.++      "Legal Entity" shall mean the union of the acting entity and all+      other entities that control, are controlled by, or are under common+      control with that entity. For the purposes of this definition,+      "control" means (i) the power, direct or indirect, to cause the+      direction or management of such entity, whether by contract or+      otherwise, or (ii) ownership of fifty percent (50%) or more of the+      outstanding shares, or (iii) beneficial ownership of such entity.++      "You" (or "Your") shall mean an individual or Legal Entity+      exercising permissions granted by this License.++      "Source" form shall mean the preferred form for making modifications,+      including but not limited to software source code, documentation+      source, and configuration files.++      "Object" form shall mean any form resulting from mechanical+      transformation or translation of a Source form, including but+      not limited to compiled object code, generated documentation,+      and conversions to other media types.++      "Work" shall mean the work of authorship, whether in Source or+      Object form, made available under the License, as indicated by a+      copyright notice that is included in or attached to the work+      (an example is provided in the Appendix below).++      "Derivative Works" shall mean any work, whether in Source or Object+      form, that is based on (or derived from) the Work and for which the+      editorial revisions, annotations, elaborations, or other modifications+      represent, as a whole, an original work of authorship. For the purposes+      of this License, Derivative Works shall not include works that remain+      separable from, or merely link (or bind by name) to the interfaces of,+      the Work and Derivative Works thereof.++      "Contribution" shall mean any work of authorship, including+      the original version of the Work and any modifications or additions+      to that Work or Derivative Works thereof, that is intentionally+      submitted to Licensor for inclusion in the Work by the copyright owner+      or by an individual or Legal Entity authorized to submit on behalf of+      the copyright owner. For the purposes of this definition, "submitted"+      means any form of electronic, verbal, or written communication sent+      to the Licensor or its representatives, including but not limited to+      communication on electronic mailing lists, source code control systems,+      and issue tracking systems that are managed by, or on behalf of, the+      Licensor for the purpose of discussing and improving the Work, but+      excluding communication that is conspicuously marked or otherwise+      designated in writing by the copyright owner as "Not a Contribution."++      "Contributor" shall mean Licensor and any individual or Legal Entity+      on behalf of whom a Contribution has been received by Licensor and+      subsequently incorporated within the Work.++   2. Grant of Copyright License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      copyright license to reproduce, prepare Derivative Works of,+      publicly display, publicly perform, sublicense, and distribute the+      Work and such Derivative Works in Source or Object form.++   3. Grant of Patent License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      (except as stated in this section) patent license to make, have made,+      use, offer to sell, sell, import, and otherwise transfer the Work,+      where such license applies only to those patent claims licensable+      by such Contributor that are necessarily infringed by their+      Contribution(s) alone or by combination of their Contribution(s)+      with the Work to which such Contribution(s) was submitted. If You+      institute patent litigation against any entity (including a+      cross-claim or counterclaim in a lawsuit) alleging that the Work+      or a Contribution incorporated within the Work constitutes direct+      or contributory patent infringement, then any patent licenses+      granted to You under this License for that Work shall terminate+      as of the date such litigation is filed.++   4. Redistribution. You may reproduce and distribute copies of the+      Work or Derivative Works thereof in any medium, with or without+      modifications, and in Source or Object form, provided that You+      meet the following conditions:++      (a) You must give any other recipients of the Work or+          Derivative Works a copy of this License; and++      (b) You must cause any modified files to carry prominent notices+          stating that You changed the files; and++      (c) You must retain, in the Source form of any Derivative Works+          that You distribute, all copyright, patent, trademark, and+          attribution notices from the Source form of the Work,+          excluding those notices that do not pertain to any part of+          the Derivative Works; and++      (d) If the Work includes a "NOTICE" text file as part of its+          distribution, then any Derivative Works that You distribute must+          include a readable copy of the attribution notices contained+          within such NOTICE file, excluding those notices that do not+          pertain to any part of the Derivative Works, in at least one+          of the following places: within a NOTICE text file distributed+          as part of the Derivative Works; within the Source form or+          documentation, if provided along with the Derivative Works; or,+          within a display generated by the Derivative Works, if and+          wherever such third-party notices normally appear. The contents+          of the NOTICE file are for informational purposes only and+          do not modify the License. You may add Your own attribution+          notices within Derivative Works that You distribute, alongside+          or as an addendum to the NOTICE text from the Work, provided+          that such additional attribution notices cannot be construed+          as modifying the License.++      You may add Your own copyright statement to Your modifications and+      may provide additional or different license terms and conditions+      for use, reproduction, or distribution of Your modifications, or+      for any such Derivative Works as a whole, provided Your use,+      reproduction, and distribution of the Work otherwise complies with+      the conditions stated in this License.++   5. Submission of Contributions. Unless You explicitly state otherwise,+      any Contribution intentionally submitted for inclusion in the Work+      by You to the Licensor shall be under the terms and conditions of+      this License, without any additional terms or conditions.+      Notwithstanding the above, nothing herein shall supersede or modify+      the terms of any separate license agreement you may have executed+      with Licensor regarding such Contributions.++   6. Trademarks. This License does not grant permission to use the trade+      names, trademarks, service marks, or product names of the Licensor,+      except as required for reasonable and customary use in describing the+      origin of the Work and reproducing the content of the NOTICE file.++   7. Disclaimer of Warranty. Unless required by applicable law or+      agreed to in writing, Licensor provides the Work (and each+      Contributor provides its Contributions) on an "AS IS" BASIS,+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+      implied, including, without limitation, any warranties or conditions+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+      PARTICULAR PURPOSE. You are solely responsible for determining the+      appropriateness of using or redistributing the Work and assume any+      risks associated with Your exercise of permissions under this License.++   8. Limitation of Liability. In no event and under no legal theory,+      whether in tort (including negligence), contract, or otherwise,+      unless required by applicable law (such as deliberate and grossly+      negligent acts) or agreed to in writing, shall any Contributor be+      liable to You for damages, including any direct, indirect, special,+      incidental, or consequential damages of any character arising as a+      result of this License or out of the use or inability to use the+      Work (including but not limited to damages for loss of goodwill,+      work stoppage, computer failure or malfunction, or any and all+      other commercial damages or losses), even if such Contributor+      has been advised of the possibility of such damages.++   9. Accepting Warranty or Additional Liability. While redistributing+      the Work or Derivative Works thereof, You may choose to offer,+      and charge a fee for, acceptance of support, warranty, indemnity,+      or other liability obligations and/or rights consistent with this+      License. However, in accepting such obligations, You may act only+      on Your own behalf and on Your sole responsibility, not on behalf+      of any other Contributor, and only if You agree to indemnify,+      defend, and hold each Contributor harmless for any liability+      incurred by, or claims asserted against, such Contributor by reason+      of your accepting any such warranty or additional liability.++   END OF TERMS AND CONDITIONS++   APPENDIX: How to apply the Apache License to your work.++      To apply the Apache License to your work, attach the following+      boilerplate notice, with the fields enclosed by brackets "[]"+      replaced with your own identifying information. (Don't include+      the brackets!)  The text should be enclosed in the appropriate+      comment syntax for the file format. We also recommend that a+      file or class name and description of purpose be included on the+      same "printed page" as the copyright notice for easier+      identification within third-party archives.++   Copyright [yyyy] [name of copyright owner]++   Licensed under the Apache License, Version 2.0 (the "License");+   you may not use this file except in compliance with the License.+   You may obtain a copy of the License at++       http://www.apache.org/licenses/LICENSE-2.0++   Unless required by applicable law or agreed to in writing, software+   distributed under the License is distributed on an "AS IS" BASIS,+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+   See the License for the specific language governing permissions and+   limitations under the License.

@@ -0,0 +1,3 @@+Hydra+Copyright 2021-2026 The Hydra authors+https://github.com/CategoricalData/hydra

@@ -0,0 +1,50 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.39.1.+--+-- see: https://github.com/sol/hpack++name:           hydra-rdf+version:        0.17.0+synopsis:       Hydra's RDF/SHACL/OWL model and coder support+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". RDF support for Hydra+category:       Data+homepage:       https://github.com/CategoricalData/hydra#readme+bug-reports:    https://github.com/CategoricalData/hydra/issues+author:         Joshua Shinavier <josh@fortytwo.net>+maintainer:     Joshua Shinavier <josh@fortytwo.net>+license:        Apache-2.0+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    LICENSE+    NOTICE+    CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/CategoricalData/hydra++library+  exposed-modules:+      Hydra.Dsl.Rdf.Syntax+      Hydra.Dsl.Shacl.Model+      Hydra.Owl.Syntax+      Hydra.Rdf.Serde+      Hydra.Rdf.Syntax+      Hydra.Rdf.Utils+      Hydra.Shacl.Coder+      Hydra.Shacl.Language+      Hydra.Shacl.Model+      Hydra.Shex.Syntax+      Hydra.Xml.Schema+  other-modules:+      Paths_hydra_rdf+  hs-source-dirs:+      src/main/haskell+  build-depends:+      base >=4.19.0 && <4.22+    , containers >=0.6.7 && <0.8+    , hydra-kernel ==0.17.0+    , scientific >=0.3.7 && <0.4+  default-language: Haskell2010

@@ -0,0 +1,706 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.rdf.syntax++module Hydra.Dsl.Rdf.Syntax where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for the hydra.rdf.syntax.BlankNode wrapper+blankNode :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.BlankNode+blankNode x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.BlankNode"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.rdf.syntax.Dataset wrapper+dataset :: Typed.TypedTerm (S.Set Syntax.Quad) -> Typed.TypedTerm Syntax.Dataset+dataset x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Dataset"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.rdf.syntax.Description+description :: Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm Syntax.Description+description subject graph =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm subject)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)}]}))+-- | DSL accessor for the graph field of hydra.rdf.syntax.Description+descriptionGraph :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Graph+descriptionGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subject field of hydra.rdf.syntax.Description+descriptionSubject :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Node+descriptionSubject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),+        Core.projectionFieldName = (Core.Name "subject")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the graph field of hydra.rdf.syntax.Description+descriptionWithGraph :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm Syntax.Description+descriptionWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the subject field of hydra.rdf.syntax.Description+descriptionWithSubject :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Description+descriptionWithSubject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Description"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Description"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.rdf.syntax.Graph wrapper+graph :: Typed.TypedTerm (S.Set Syntax.Triple) -> Typed.TypedTerm Syntax.Graph+graph x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Graph"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.rdf.syntax.Iri wrapper+iri :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Iri+iri x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.Iri"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the iri variant of hydra.rdf.syntax.IriOrLiteral+iriOrLiteralIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.IriOrLiteral+iriOrLiteralIri x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.IriOrLiteral"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "iri"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the literal variant of hydra.rdf.syntax.IriOrLiteral+iriOrLiteralLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.IriOrLiteral+iriOrLiteralLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.IriOrLiteral"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for the hydra.rdf.syntax.LangStrings wrapper+langStrings :: Typed.TypedTerm (M.Map (Maybe Syntax.LanguageTag) String) -> Typed.TypedTerm Syntax.LangStrings+langStrings x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.LangStrings"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.rdf.syntax.LanguageTag wrapper+languageTag :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.LanguageTag+languageTag x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.LanguageTag"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.rdf.syntax.Literal+literal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Maybe Syntax.LanguageTag) -> Typed.TypedTerm Syntax.Literal+literal lexicalForm datatypeIri languageTag =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lexicalForm"),+          Core.fieldTerm = (Typed.unTypedTerm lexicalForm)},+        Core.Field {+          Core.fieldName = (Core.Name "datatypeIri"),+          Core.fieldTerm = (Typed.unTypedTerm datatypeIri)},+        Core.Field {+          Core.fieldName = (Core.Name "languageTag"),+          Core.fieldTerm = (Typed.unTypedTerm languageTag)}]}))+-- | DSL accessor for the datatypeIri field of hydra.rdf.syntax.Literal+literalDatatypeIri :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Iri+literalDatatypeIri x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+        Core.projectionFieldName = (Core.Name "datatypeIri")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the languageTag field of hydra.rdf.syntax.Literal+literalLanguageTag :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm (Maybe Syntax.LanguageTag)+literalLanguageTag x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+        Core.projectionFieldName = (Core.Name "languageTag")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the lexicalForm field of hydra.rdf.syntax.Literal+literalLexicalForm :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm String+literalLexicalForm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+        Core.projectionFieldName = (Core.Name "lexicalForm")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the datatypeIri field of hydra.rdf.syntax.Literal+literalWithDatatypeIri :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Literal+literalWithDatatypeIri original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lexicalForm"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "lexicalForm")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "datatypeIri"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "languageTag"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "languageTag")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the languageTag field of hydra.rdf.syntax.Literal+literalWithLanguageTag :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm (Maybe Syntax.LanguageTag) -> Typed.TypedTerm Syntax.Literal+literalWithLanguageTag original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lexicalForm"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "lexicalForm")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "datatypeIri"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "datatypeIri")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "languageTag"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the lexicalForm field of hydra.rdf.syntax.Literal+literalWithLexicalForm :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal+literalWithLexicalForm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lexicalForm"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "datatypeIri"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "datatypeIri")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "languageTag"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"),+              Core.projectionFieldName = (Core.Name "languageTag")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the bnode variant of hydra.rdf.syntax.Node+nodeBnode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm Syntax.Node+nodeBnode x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bnode"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the iri variant of hydra.rdf.syntax.Node+nodeIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node+nodeIri x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "iri"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the literal variant of hydra.rdf.syntax.Node+nodeLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Node+nodeLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.rdf.syntax.Property+property :: Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Syntax.Property+property domain range subPropertyOf =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm domain)},+        Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (Typed.unTypedTerm range)},+        Core.Field {+          Core.fieldName = (Core.Name "subPropertyOf"),+          Core.fieldTerm = (Typed.unTypedTerm subPropertyOf)}]}))+-- | DSL accessor for the domain field of hydra.rdf.syntax.Property+propertyDomain :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass)+propertyDomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+        Core.projectionFieldName = (Core.Name "domain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the range field of hydra.rdf.syntax.Property+propertyRange :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass)+propertyRange x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+        Core.projectionFieldName = (Core.Name "range")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subPropertyOf field of hydra.rdf.syntax.Property+propertySubPropertyOf :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.Property)+propertySubPropertyOf x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+        Core.projectionFieldName = (Core.Name "subPropertyOf")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the domain field of hydra.rdf.syntax.Property+propertyWithDomain :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Syntax.Property+propertyWithDomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "range")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subPropertyOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "subPropertyOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the range field of hydra.rdf.syntax.Property+propertyWithRange :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Syntax.Property+propertyWithRange original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "subPropertyOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "subPropertyOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the subPropertyOf field of hydra.rdf.syntax.Property+propertyWithSubPropertyOf :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Syntax.Property+propertyWithSubPropertyOf original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Property"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"),+              Core.projectionFieldName = (Core.Name "range")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subPropertyOf"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.rdf.syntax.Quad+quad :: Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm (Maybe Syntax.Iri) -> Typed.TypedTerm Syntax.Quad+quad subject predicate object graph =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm subject)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm predicate)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm object)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)}]}))+-- | DSL accessor for the graph field of hydra.rdf.syntax.Quad+quadGraph :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm (Maybe Syntax.Iri)+quadGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the object field of hydra.rdf.syntax.Quad+quadObject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Node+quadObject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+        Core.projectionFieldName = (Core.Name "object")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the predicate field of hydra.rdf.syntax.Quad+quadPredicate :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Iri+quadPredicate x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+        Core.projectionFieldName = (Core.Name "predicate")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subject field of hydra.rdf.syntax.Quad+quadSubject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Resource+quadSubject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+        Core.projectionFieldName = (Core.Name "subject")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the graph field of hydra.rdf.syntax.Quad+quadWithGraph :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm (Maybe Syntax.Iri) -> Typed.TypedTerm Syntax.Quad+quadWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the object field of hydra.rdf.syntax.Quad+quadWithObject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Quad+quadWithObject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the predicate field of hydra.rdf.syntax.Quad+quadWithPredicate :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Quad+quadWithPredicate original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the subject field of hydra.rdf.syntax.Quad+quadWithSubject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Quad+quadWithSubject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.rdf.syntax.RdfsClass wrapper+rdfsClass :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.RdfsClass+rdfsClass x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.rdf.syntax.RdfsClass"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the bnode variant of hydra.rdf.syntax.Resource+resourceBnode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm Syntax.Resource+resourceBnode x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Resource"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bnode"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the iri variant of hydra.rdf.syntax.Resource+resourceIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Resource+resourceIri x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.rdf.syntax.Resource"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "iri"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.rdf.syntax.Triple+triple :: Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Triple+triple subject predicate object =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm subject)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm predicate)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm object)}]}))+-- | DSL accessor for the object field of hydra.rdf.syntax.Triple+tripleObject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Node+tripleObject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+        Core.projectionFieldName = (Core.Name "object")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the predicate field of hydra.rdf.syntax.Triple+triplePredicate :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Iri+triplePredicate x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+        Core.projectionFieldName = (Core.Name "predicate")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subject field of hydra.rdf.syntax.Triple+tripleSubject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Resource+tripleSubject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+        Core.projectionFieldName = (Core.Name "subject")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the object field of hydra.rdf.syntax.Triple+tripleWithObject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Triple+tripleWithObject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the predicate field of hydra.rdf.syntax.Triple+tripleWithPredicate :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.Triple+tripleWithPredicate original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the subject field of hydra.rdf.syntax.Triple+tripleWithSubject :: Typed.TypedTerm Syntax.Triple -> Typed.TypedTerm Syntax.Resource -> Typed.TypedTerm Syntax.Triple+tripleWithSubject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.rdf.syntax.BlankNode+unBlankNode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm String+unBlankNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.BlankNode")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.Dataset+unDataset :: Typed.TypedTerm Syntax.Dataset -> Typed.TypedTerm (S.Set Syntax.Quad)+unDataset x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Dataset")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.Graph+unGraph :: Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm (S.Set Syntax.Triple)+unGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Graph")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.Iri+unIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm String+unIri x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.Iri")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.LangStrings+unLangStrings :: Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm (M.Map (Maybe Syntax.LanguageTag) String)+unLangStrings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.LangStrings")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.LanguageTag+unLanguageTag :: Typed.TypedTerm Syntax.LanguageTag -> Typed.TypedTerm String+unLanguageTag x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.LanguageTag")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.rdf.syntax.RdfsClass+unRdfsClass :: Typed.TypedTerm Syntax.RdfsClass -> Typed.TypedTerm ()+unRdfsClass x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.rdf.syntax.RdfsClass")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))

@@ -0,0 +1,1735 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.shacl.model++module Hydra.Dsl.Shacl.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Rdf.Syntax as RdfSyntax+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Shacl.Model as Model+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | DSL constructor for hydra.shacl.model.Closed+closed :: Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm Model.Closed+closed isClosed ignoredProperties =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isClosed"),+          Core.fieldTerm = (Typed.unTypedTerm isClosed)},+        Core.Field {+          Core.fieldName = (Core.Name "ignoredProperties"),+          Core.fieldTerm = (Typed.unTypedTerm ignoredProperties)}]}))+-- | DSL accessor for the ignoredProperties field of hydra.shacl.model.Closed+closedIgnoredProperties :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property))+closedIgnoredProperties x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),+        Core.projectionFieldName = (Core.Name "ignoredProperties")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the isClosed field of hydra.shacl.model.Closed+closedIsClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Bool+closedIsClosed x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),+        Core.projectionFieldName = (Core.Name "isClosed")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the ignoredProperties field of hydra.shacl.model.Closed+closedWithIgnoredProperties :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm Model.Closed+closedWithIgnoredProperties original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isClosed"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),+              Core.projectionFieldName = (Core.Name "isClosed")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ignoredProperties"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the isClosed field of hydra.shacl.model.Closed+closedWithIsClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Bool -> Typed.TypedTerm Model.Closed+closedWithIsClosed original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Closed"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isClosed"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "ignoredProperties"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Closed"),+              Core.projectionFieldName = (Core.Name "ignoredProperties")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the and variant of hydra.shacl.model.CommonConstraint+commonConstraintAnd :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintAnd x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "and"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the class variant of hydra.shacl.model.CommonConstraint+commonConstraintClass :: Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintClass x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "class"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the closed variant of hydra.shacl.model.CommonConstraint+commonConstraintClosed :: Typed.TypedTerm Model.Closed -> Typed.TypedTerm Model.CommonConstraint+commonConstraintClosed x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "closed"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the datatype variant of hydra.shacl.model.CommonConstraint+commonConstraintDatatype :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.CommonConstraint+commonConstraintDatatype x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "datatype"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the disjoint variant of hydra.shacl.model.CommonConstraint+commonConstraintDisjoint :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintDisjoint x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "disjoint"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the equals variant of hydra.shacl.model.CommonConstraint+commonConstraintEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintEquals x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "equals"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the hasValue variant of hydra.shacl.model.CommonConstraint+commonConstraintHasValue :: Typed.TypedTerm (S.Set Syntax.Node) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintHasValue x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "hasValue"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the in variant of hydra.shacl.model.CommonConstraint+commonConstraintIn :: Typed.TypedTerm [Syntax.Node] -> Typed.TypedTerm Model.CommonConstraint+commonConstraintIn x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "in"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the languageIn variant of hydra.shacl.model.CommonConstraint+commonConstraintLanguageIn :: Typed.TypedTerm (S.Set Syntax.LanguageTag) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintLanguageIn x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "languageIn"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the maxExclusive variant of hydra.shacl.model.CommonConstraint+commonConstraintMaxExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMaxExclusive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "maxExclusive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the maxInclusive variant of hydra.shacl.model.CommonConstraint+commonConstraintMaxInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMaxInclusive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "maxInclusive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the maxLength variant of hydra.shacl.model.CommonConstraint+commonConstraintMaxLength :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMaxLength x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "maxLength"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the minExclusive variant of hydra.shacl.model.CommonConstraint+commonConstraintMinExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMinExclusive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minExclusive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the minInclusive variant of hydra.shacl.model.CommonConstraint+commonConstraintMinInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMinInclusive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minInclusive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the minLength variant of hydra.shacl.model.CommonConstraint+commonConstraintMinLength :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.CommonConstraint+commonConstraintMinLength x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minLength"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the node variant of hydra.shacl.model.CommonConstraint+commonConstraintNode :: Typed.TypedTerm (S.Set (Model.Reference Model.NodeShape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintNode x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "node"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the nodeKind variant of hydra.shacl.model.CommonConstraint+commonConstraintNodeKind :: Typed.TypedTerm Model.NodeKind -> Typed.TypedTerm Model.CommonConstraint+commonConstraintNodeKind x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nodeKind"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the not variant of hydra.shacl.model.CommonConstraint+commonConstraintNot :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintNot x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "not"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the or variant of hydra.shacl.model.CommonConstraint+commonConstraintOr :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintOr x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "or"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the pattern variant of hydra.shacl.model.CommonConstraint+commonConstraintPattern :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm Model.CommonConstraint+commonConstraintPattern x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pattern"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the property variant of hydra.shacl.model.CommonConstraint+commonConstraintProperty :: Typed.TypedTerm (S.Set (Model.Reference Model.PropertyShape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintProperty x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "property"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the xone variant of hydra.shacl.model.CommonConstraint+commonConstraintXone :: Typed.TypedTerm (S.Set (Model.Reference Model.Shape)) -> Typed.TypedTerm Model.CommonConstraint+commonConstraintXone x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.CommonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "xone"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.shacl.model.CommonProperties+commonProperties :: Typed.TypedTerm (S.Set Model.CommonConstraint) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.Severity -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties+commonProperties constraints deactivated message severity targetClass targetNode targetObjectsOf targetSubjectsOf =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm constraints)},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Typed.unTypedTerm deactivated)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm message)},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm severity)},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Typed.unTypedTerm targetClass)},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Typed.unTypedTerm targetNode)},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Typed.unTypedTerm targetObjectsOf)},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Typed.unTypedTerm targetSubjectsOf)}]}))+-- | DSL accessor for the constraints field of hydra.shacl.model.CommonProperties+commonPropertiesConstraints :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.CommonConstraint)+commonPropertiesConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "constraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the deactivated field of hydra.shacl.model.CommonProperties+commonPropertiesDeactivated :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (Maybe Bool)+commonPropertiesDeactivated x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "deactivated")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the message field of hydra.shacl.model.CommonProperties+commonPropertiesMessage :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Syntax.LangStrings+commonPropertiesMessage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "message")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the severity field of hydra.shacl.model.CommonProperties+commonPropertiesSeverity :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.Severity+commonPropertiesSeverity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "severity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the targetClass field of hydra.shacl.model.CommonProperties+commonPropertiesTargetClass :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass)+commonPropertiesTargetClass x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "targetClass")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the targetNode field of hydra.shacl.model.CommonProperties+commonPropertiesTargetNode :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral)+commonPropertiesTargetNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "targetNode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the targetObjectsOf field of hydra.shacl.model.CommonProperties+commonPropertiesTargetObjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)+commonPropertiesTargetObjectsOf x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the targetSubjectsOf field of hydra.shacl.model.CommonProperties+commonPropertiesTargetSubjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)+commonPropertiesTargetSubjectsOf x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+        Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the constraints field of hydra.shacl.model.CommonProperties+commonPropertiesWithConstraints :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.CommonConstraint) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the deactivated field of hydra.shacl.model.CommonProperties+commonPropertiesWithDeactivated :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithDeactivated original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the message field of hydra.shacl.model.CommonProperties+commonPropertiesWithMessage :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithMessage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the severity field of hydra.shacl.model.CommonProperties+commonPropertiesWithSeverity :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.Severity -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithSeverity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the targetClass field of hydra.shacl.model.CommonProperties+commonPropertiesWithTargetClass :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithTargetClass original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the targetNode field of hydra.shacl.model.CommonProperties+commonPropertiesWithTargetNode :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithTargetNode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the targetObjectsOf field of hydra.shacl.model.CommonProperties+commonPropertiesWithTargetObjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithTargetObjectsOf original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetSubjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the targetSubjectsOf field of hydra.shacl.model.CommonProperties+commonPropertiesWithTargetSubjectsOf :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.CommonProperties+commonPropertiesWithTargetSubjectsOf original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deactivated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "deactivated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetClass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetClass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetObjectsOf"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.CommonProperties"),+              Core.projectionFieldName = (Core.Name "targetObjectsOf")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetSubjectsOf"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.shacl.model.Definition+definition :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm a -> Typed.TypedTerm (Model.Definition a)+definition iri target =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "iri"),+          Core.fieldTerm = (Typed.unTypedTerm iri)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))+-- | DSL accessor for the iri field of hydra.shacl.model.Definition+definitionIri :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm Syntax.Iri+definitionIri x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),+        Core.projectionFieldName = (Core.Name "iri")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the target field of hydra.shacl.model.Definition+definitionTarget :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm a+definitionTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the iri field of hydra.shacl.model.Definition+definitionWithIri :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Model.Definition a)+definitionWithIri original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "iri"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the target field of hydra.shacl.model.Definition+definitionWithTarget :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm a -> Typed.TypedTerm (Model.Definition a)+definitionWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Definition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "iri"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Definition"),+              Core.projectionFieldName = (Core.Name "iri")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the blankNode variant of hydra.shacl.model.NodeKind+nodeKindBlankNode :: Typed.TypedTerm Model.NodeKind+nodeKindBlankNode =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "blankNode"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the blankNodeOrIri variant of hydra.shacl.model.NodeKind+nodeKindBlankNodeOrIri :: Typed.TypedTerm Model.NodeKind+nodeKindBlankNodeOrIri =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "blankNodeOrIri"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the blankNodeOrLiteral variant of hydra.shacl.model.NodeKind+nodeKindBlankNodeOrLiteral :: Typed.TypedTerm Model.NodeKind+nodeKindBlankNodeOrLiteral =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "blankNodeOrLiteral"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the iri variant of hydra.shacl.model.NodeKind+nodeKindIri :: Typed.TypedTerm Model.NodeKind+nodeKindIri =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "iri"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the iriOrLiteral variant of hydra.shacl.model.NodeKind+nodeKindIriOrLiteral :: Typed.TypedTerm Model.NodeKind+nodeKindIriOrLiteral =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "iriOrLiteral"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the literal variant of hydra.shacl.model.NodeKind+nodeKindLiteral :: Typed.TypedTerm Model.NodeKind+nodeKindLiteral =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.NodeKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.shacl.model.NodeShape+nodeShape :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.NodeShape+nodeShape common =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.NodeShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Typed.unTypedTerm common)}]}))+-- | DSL accessor for the common field of hydra.shacl.model.NodeShape+nodeShapeCommon :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.CommonProperties+nodeShapeCommon x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.NodeShape"),+        Core.projectionFieldName = (Core.Name "common")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the common field of hydra.shacl.model.NodeShape+nodeShapeWithCommon :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.NodeShape+nodeShapeWithCommon original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.NodeShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.shacl.model.Pattern+pattern :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Model.Pattern+pattern regex flags =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "regex"),+          Core.fieldTerm = (Typed.unTypedTerm regex)},+        Core.Field {+          Core.fieldName = (Core.Name "flags"),+          Core.fieldTerm = (Typed.unTypedTerm flags)}]}))+-- | DSL accessor for the flags field of hydra.shacl.model.Pattern+patternFlags :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm (Maybe String)+patternFlags x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),+        Core.projectionFieldName = (Core.Name "flags")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the regex field of hydra.shacl.model.Pattern+patternRegex :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm String+patternRegex x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),+        Core.projectionFieldName = (Core.Name "regex")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the flags field of hydra.shacl.model.Pattern+patternWithFlags :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Model.Pattern+patternWithFlags original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "regex"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),+              Core.projectionFieldName = (Core.Name "regex")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "flags"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the regex field of hydra.shacl.model.Pattern+patternWithRegex :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm String -> Typed.TypedTerm Model.Pattern+patternWithRegex original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.Pattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "regex"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "flags"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"),+              Core.projectionFieldName = (Core.Name "flags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.shacl.model.PropertyShape+propertyShape :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint) -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.PropertyShape+propertyShape common constraints defaultValue description name order path =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Typed.unTypedTerm common)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm constraints)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Typed.unTypedTerm defaultValue)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Typed.unTypedTerm order)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)}]}))+-- | DSL accessor for the common field of hydra.shacl.model.PropertyShape+propertyShapeCommon :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.CommonProperties+propertyShapeCommon x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "common")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL injection for the lessThan variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintLessThan :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintLessThan x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lessThan"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the lessThanOrEquals variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintLessThanOrEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintLessThanOrEquals x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lessThanOrEquals"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the maxCount variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintMaxCount :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintMaxCount x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "maxCount"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the minCount variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintMinCount :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintMinCount x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minCount"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the qualifiedValueShape variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintQualifiedValueShape x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "qualifiedValueShape"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the uniqueLang variant of hydra.shacl.model.PropertyShapeConstraint+propertyShapeConstraintUniqueLang :: Typed.TypedTerm Bool -> Typed.TypedTerm Model.PropertyShapeConstraint+propertyShapeConstraintUniqueLang x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.PropertyShapeConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uniqueLang"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL accessor for the constraints field of hydra.shacl.model.PropertyShape+propertyShapeConstraints :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint)+propertyShapeConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "constraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the defaultValue field of hydra.shacl.model.PropertyShape+propertyShapeDefaultValue :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node)+propertyShapeDefaultValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "defaultValue")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the description field of hydra.shacl.model.PropertyShape+propertyShapeDescription :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings+propertyShapeDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.shacl.model.PropertyShape+propertyShapeName :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings+propertyShapeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the order field of hydra.shacl.model.PropertyShape+propertyShapeOrder :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Integer)+propertyShapeOrder x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "order")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.shacl.model.PropertyShape+propertyShapePath :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.Iri+propertyShapePath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the common field of hydra.shacl.model.PropertyShape+propertyShapeWithCommon :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithCommon original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the constraints field of hydra.shacl.model.PropertyShape+propertyShapeWithConstraints :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (S.Set Model.PropertyShapeConstraint) -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the defaultValue field of hydra.shacl.model.PropertyShape+propertyShapeWithDefaultValue :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithDefaultValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the description field of hydra.shacl.model.PropertyShape+propertyShapeWithDescription :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.shacl.model.PropertyShape+propertyShapeWithName :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the order field of hydra.shacl.model.PropertyShape+propertyShapeWithOrder :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithOrder original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the path field of hydra.shacl.model.PropertyShape+propertyShapeWithPath :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.PropertyShape+propertyShapeWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "common"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "common")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "defaultValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "order"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"),+              Core.projectionFieldName = (Core.Name "order")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.shacl.model.QualifiedValueShape+qualifiedValueShape :: Typed.TypedTerm (Model.Reference Model.Shape) -> Typed.TypedTerm Integer -> Typed.TypedTerm Integer -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.QualifiedValueShape+qualifiedValueShape qualifiedValueShape qualifiedMaxCount qualifiedMinCount qualifiedValueShapesDisjoint =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShape"),+          Core.fieldTerm = (Typed.unTypedTerm qualifiedValueShape)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMaxCount"),+          Core.fieldTerm = (Typed.unTypedTerm qualifiedMaxCount)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMinCount"),+          Core.fieldTerm = (Typed.unTypedTerm qualifiedMinCount)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),+          Core.fieldTerm = (Typed.unTypedTerm qualifiedValueShapesDisjoint)}]}))+-- | DSL accessor for the qualifiedMaxCount field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeQualifiedMaxCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer+qualifiedValueShapeQualifiedMaxCount x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+        Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the qualifiedMinCount field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeQualifiedMinCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer+qualifiedValueShapeQualifiedMinCount x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+        Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the qualifiedValueShape field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape)+qualifiedValueShapeQualifiedValueShape x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+        Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the qualifiedValueShapesDisjoint field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeQualifiedValueShapesDisjoint :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool)+qualifiedValueShapeQualifiedValueShapesDisjoint x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+        Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the qualifiedMaxCount field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeWithQualifiedMaxCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm Model.QualifiedValueShape+qualifiedValueShapeWithQualifiedMaxCount original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShape"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMaxCount"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMinCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the qualifiedMinCount field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeWithQualifiedMinCount :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm Model.QualifiedValueShape+qualifiedValueShapeWithQualifiedMinCount original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShape"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMaxCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMinCount"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the qualifiedValueShape field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeWithQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape) -> Typed.TypedTerm Model.QualifiedValueShape+qualifiedValueShapeWithQualifiedValueShape original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShape"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMaxCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMinCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShapesDisjoint")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the qualifiedValueShapesDisjoint field of hydra.shacl.model.QualifiedValueShape+qualifiedValueShapeWithQualifiedValueShapesDisjoint :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Model.QualifiedValueShape+qualifiedValueShapeWithQualifiedValueShapesDisjoint original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShape"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedValueShape")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMaxCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMaxCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedMinCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"),+              Core.projectionFieldName = (Core.Name "qualifiedMinCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "qualifiedValueShapesDisjoint"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the anonymous variant of hydra.shacl.model.Reference+referenceAnonymous :: Typed.TypedTerm a -> Typed.TypedTerm (Model.Reference a)+referenceAnonymous x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "anonymous"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the definition variant of hydra.shacl.model.Reference+referenceDefinition :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm (Model.Reference a)+referenceDefinition x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "definition"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the named variant of hydra.shacl.model.Reference+referenceNamed :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (Model.Reference a)+referenceNamed x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Reference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "named"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the info variant of hydra.shacl.model.Severity+severityInfo :: Typed.TypedTerm Model.Severity+severityInfo =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "info"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the violation variant of hydra.shacl.model.Severity+severityViolation :: Typed.TypedTerm Model.Severity+severityViolation =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "violation"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the warning variant of hydra.shacl.model.Severity+severityWarning :: Typed.TypedTerm Model.Severity+severityWarning =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Severity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "warning"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the node variant of hydra.shacl.model.Shape+shapeNode :: Typed.TypedTerm Model.NodeShape -> Typed.TypedTerm Model.Shape+shapeNode x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Shape"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "node"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the property variant of hydra.shacl.model.Shape+shapeProperty :: Typed.TypedTerm Model.PropertyShape -> Typed.TypedTerm Model.Shape+shapeProperty x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.shacl.model.Shape"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "property"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for the hydra.shacl.model.ShapesGraph wrapper+shapesGraph :: Typed.TypedTerm (S.Set (Model.Definition Model.Shape)) -> Typed.TypedTerm Model.ShapesGraph+shapesGraph x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.shacl.model.ShapesGraph"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.shacl.model.ShapesGraph+unShapesGraph :: Typed.TypedTerm Model.ShapesGraph -> Typed.TypedTerm (S.Set (Model.Definition Model.Shape))+unShapesGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.shacl.model.ShapesGraph")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))

@@ -0,0 +1,818 @@+-- Note: this is an automatically generated file. Do not edit.+-- | An OWL 2 syntax model. See https://www.w3.org/TR/owl2-syntax++module Hydra.Owl.Syntax where+import qualified Hydra.Core as Core+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Xml.Schema as Schema+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+data Ontology =+  Ontology {+    ontologyDirectImports :: [Ontology],+    ontologyAnnotations :: [Annotation],+    ontologyAxioms :: [Axiom]}+  deriving (Eq, Ord, Read, Show)+_Ontology = Core.Name "hydra.owl.syntax.Ontology"+_Ontology_directImports = Core.Name "directImports"+_Ontology_annotations = Core.Name "annotations"+_Ontology_axioms = Core.Name "axioms"+data Declaration =+  Declaration {+    declarationAnnotations :: [Annotation],+    declarationEntity :: Entity}+  deriving (Eq, Ord, Read, Show)+_Declaration = Core.Name "hydra.owl.syntax.Declaration"+_Declaration_annotations = Core.Name "annotations"+_Declaration_entity = Core.Name "entity"+data Entity =+  EntityAnnotationProperty AnnotationProperty |+  EntityClass Class |+  EntityDataProperty DataProperty |+  EntityDatatype Datatype |+  EntityNamedIndividual NamedIndividual |+  EntityObjectProperty ObjectProperty+  deriving (Eq, Ord, Read, Show)+_Entity = Core.Name "hydra.owl.syntax.Entity"+_Entity_annotationProperty = Core.Name "annotationProperty"+_Entity_class = Core.Name "class"+_Entity_dataProperty = Core.Name "dataProperty"+_Entity_datatype = Core.Name "datatype"+_Entity_namedIndividual = Core.Name "namedIndividual"+_Entity_objectProperty = Core.Name "objectProperty"+data AnnotationSubject =+  AnnotationSubjectIri Syntax.Iri |+  AnnotationSubjectAnonymousIndividual AnonymousIndividual+  deriving (Eq, Ord, Read, Show)+_AnnotationSubject = Core.Name "hydra.owl.syntax.AnnotationSubject"+_AnnotationSubject_iri = Core.Name "iri"+_AnnotationSubject_anonymousIndividual = Core.Name "anonymousIndividual"+data AnnotationValue =+  AnnotationValueAnonymousIndividual AnonymousIndividual |+  AnnotationValueIri Syntax.Iri |+  AnnotationValueLiteral Syntax.Literal+  deriving (Eq, Ord, Read, Show)+_AnnotationValue = Core.Name "hydra.owl.syntax.AnnotationValue"+_AnnotationValue_anonymousIndividual = Core.Name "anonymousIndividual"+_AnnotationValue_iri = Core.Name "iri"+_AnnotationValue_literal = Core.Name "literal"+data Annotation =+  Annotation {+    annotationAnnotations :: [Annotation],+    annotationProperty :: AnnotationProperty,+    annotationValue :: AnnotationValue}+  deriving (Eq, Ord, Read, Show)+_Annotation = Core.Name "hydra.owl.syntax.Annotation"+_Annotation_annotations = Core.Name "annotations"+_Annotation_property = Core.Name "property"+_Annotation_value = Core.Name "value"+data AnnotationAxiom =+  AnnotationAxiomAnnotationAssertion AnnotationAssertion |+  AnnotationAxiomAnnotationPropertyDomain AnnotationPropertyDomain |+  AnnotationAxiomAnnotationPropertyRange AnnotationPropertyRange |+  AnnotationAxiomSubAnnotationPropertyOf SubAnnotationPropertyOf+  deriving (Eq, Ord, Read, Show)+_AnnotationAxiom = Core.Name "hydra.owl.syntax.AnnotationAxiom"+_AnnotationAxiom_annotationAssertion = Core.Name "annotationAssertion"+_AnnotationAxiom_annotationPropertyDomain = Core.Name "annotationPropertyDomain"+_AnnotationAxiom_annotationPropertyRange = Core.Name "annotationPropertyRange"+_AnnotationAxiom_subAnnotationPropertyOf = Core.Name "subAnnotationPropertyOf"+data AnnotationAssertion =+  AnnotationAssertion {+    annotationAssertionAnnotations :: [Annotation],+    annotationAssertionProperty :: AnnotationProperty,+    annotationAssertionSubject :: AnnotationSubject,+    annotationAssertionValue :: AnnotationValue}+  deriving (Eq, Ord, Read, Show)+_AnnotationAssertion = Core.Name "hydra.owl.syntax.AnnotationAssertion"+_AnnotationAssertion_annotations = Core.Name "annotations"+_AnnotationAssertion_property = Core.Name "property"+_AnnotationAssertion_subject = Core.Name "subject"+_AnnotationAssertion_value = Core.Name "value"+data SubAnnotationPropertyOf =+  SubAnnotationPropertyOf {+    subAnnotationPropertyOfAnnotations :: [Annotation],+    subAnnotationPropertyOfSubProperty :: AnnotationProperty,+    subAnnotationPropertyOfSuperProperty :: AnnotationProperty}+  deriving (Eq, Ord, Read, Show)+_SubAnnotationPropertyOf = Core.Name "hydra.owl.syntax.SubAnnotationPropertyOf"+_SubAnnotationPropertyOf_annotations = Core.Name "annotations"+_SubAnnotationPropertyOf_subProperty = Core.Name "subProperty"+_SubAnnotationPropertyOf_superProperty = Core.Name "superProperty"+data AnnotationPropertyDomain =+  AnnotationPropertyDomain {+    annotationPropertyDomainAnnotations :: [Annotation],+    annotationPropertyDomainProperty :: AnnotationProperty,+    annotationPropertyDomainIri :: Syntax.Iri}+  deriving (Eq, Ord, Read, Show)+_AnnotationPropertyDomain = Core.Name "hydra.owl.syntax.AnnotationPropertyDomain"+_AnnotationPropertyDomain_annotations = Core.Name "annotations"+_AnnotationPropertyDomain_property = Core.Name "property"+_AnnotationPropertyDomain_iri = Core.Name "iri"+data AnnotationPropertyRange =+  AnnotationPropertyRange {+    annotationPropertyRangeAnnotations :: [Annotation],+    annotationPropertyRangeProperty :: AnnotationProperty,+    annotationPropertyRangeIri :: Syntax.Iri}+  deriving (Eq, Ord, Read, Show)+_AnnotationPropertyRange = Core.Name "hydra.owl.syntax.AnnotationPropertyRange"+_AnnotationPropertyRange_annotations = Core.Name "annotations"+_AnnotationPropertyRange_property = Core.Name "property"+_AnnotationPropertyRange_iri = Core.Name "iri"+-- | See https://www.w3.org/TR/owl2-syntax/#Classes+newtype Class =+  Class {+    unClass :: ()}+  deriving (Eq, Ord, Read, Show)+_Class = Core.Name "hydra.owl.syntax.Class"+-- | See https://www.w3.org/TR/owl2-syntax/#Datatypes+data Datatype =+  -- | Note: XML Schema datatypes are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common+  DatatypeXmlSchema Schema.Datatype |+  DatatypeOther Syntax.Iri+  deriving (Eq, Ord, Read, Show)+_Datatype = Core.Name "hydra.owl.syntax.Datatype"+_Datatype_xmlSchema = Core.Name "xmlSchema"+_Datatype_other = Core.Name "other"+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Properties+newtype ObjectProperty =+  ObjectProperty {+    unObjectProperty :: ()}+  deriving (Eq, Ord, Read, Show)+_ObjectProperty = Core.Name "hydra.owl.syntax.ObjectProperty"+newtype DataProperty =+  DataProperty {+    unDataProperty :: ()}+  deriving (Eq, Ord, Read, Show)+_DataProperty = Core.Name "hydra.owl.syntax.DataProperty"+newtype AnnotationProperty =+  AnnotationProperty {+    unAnnotationProperty :: ()}+  deriving (Eq, Ord, Read, Show)+_AnnotationProperty = Core.Name "hydra.owl.syntax.AnnotationProperty"+data Individual =+  IndividualNamed NamedIndividual |+  IndividualAnonymous AnonymousIndividual+  deriving (Eq, Ord, Read, Show)+_Individual = Core.Name "hydra.owl.syntax.Individual"+_Individual_named = Core.Name "named"+_Individual_anonymous = Core.Name "anonymous"+newtype NamedIndividual =+  NamedIndividual {+    unNamedIndividual :: ()}+  deriving (Eq, Ord, Read, Show)+_NamedIndividual = Core.Name "hydra.owl.syntax.NamedIndividual"+newtype AnonymousIndividual =+  AnonymousIndividual {+    unAnonymousIndividual :: ()}+  deriving (Eq, Ord, Read, Show)+_AnonymousIndividual = Core.Name "hydra.owl.syntax.AnonymousIndividual"+data ObjectPropertyExpression =+  ObjectPropertyExpressionObject ObjectProperty |+  ObjectPropertyExpressionInverseObject InverseObjectProperty+  deriving (Eq, Ord, Read, Show)+_ObjectPropertyExpression = Core.Name "hydra.owl.syntax.ObjectPropertyExpression"+_ObjectPropertyExpression_object = Core.Name "object"+_ObjectPropertyExpression_inverseObject = Core.Name "inverseObject"+newtype InverseObjectProperty =+  InverseObjectProperty {+    unInverseObjectProperty :: ObjectProperty}+  deriving (Eq, Ord, Read, Show)+_InverseObjectProperty = Core.Name "hydra.owl.syntax.InverseObjectProperty"+newtype DataPropertyExpression =+  DataPropertyExpression {+    unDataPropertyExpression :: DataProperty}+  deriving (Eq, Ord, Read, Show)+_DataPropertyExpression = Core.Name "hydra.owl.syntax.DataPropertyExpression"+-- | See https://www.w3.org/TR/owl2-syntax/#Data_Ranges+data DataRange =+  DataRangeDataComplementOf DataComplementOf |+  DataRangeDataIntersectionOf DataIntersectionOf |+  DataRangeDataOneOf DataOneOf |+  DataRangeDataUnionOf DataUnionOf |+  DataRangeDatatype Datatype |+  DataRangeDatatypeRestriction DatatypeRestriction+  deriving (Eq, Ord, Read, Show)+_DataRange = Core.Name "hydra.owl.syntax.DataRange"+_DataRange_dataComplementOf = Core.Name "dataComplementOf"+_DataRange_dataIntersectionOf = Core.Name "dataIntersectionOf"+_DataRange_dataOneOf = Core.Name "dataOneOf"+_DataRange_dataUnionOf = Core.Name "dataUnionOf"+_DataRange_datatype = Core.Name "datatype"+_DataRange_datatypeRestriction = Core.Name "datatypeRestriction"+-- | See https://www.w3.org/TR/owl2-syntax/#Intersection_of_Data_Ranges+newtype DataIntersectionOf =+  DataIntersectionOf {+    unDataIntersectionOf :: [DataRange]}+  deriving (Eq, Ord, Read, Show)+_DataIntersectionOf = Core.Name "hydra.owl.syntax.DataIntersectionOf"+-- | See https://www.w3.org/TR/owl2-syntax/#Union_of_Data_Ranges+newtype DataUnionOf =+  DataUnionOf {+    unDataUnionOf :: [DataRange]}+  deriving (Eq, Ord, Read, Show)+_DataUnionOf = Core.Name "hydra.owl.syntax.DataUnionOf"+-- | See https://www.w3.org/TR/owl2-syntax/#Complement_of_Data_Ranges+newtype DataComplementOf =+  DataComplementOf {+    unDataComplementOf :: DataRange}+  deriving (Eq, Ord, Read, Show)+_DataComplementOf = Core.Name "hydra.owl.syntax.DataComplementOf"+-- | See https://www.w3.org/TR/owl2-syntax/#Enumeration_of_Literals+newtype DataOneOf =+  DataOneOf {+    unDataOneOf :: [Syntax.Literal]}+  deriving (Eq, Ord, Read, Show)+_DataOneOf = Core.Name "hydra.owl.syntax.DataOneOf"+-- | See https://www.w3.org/TR/owl2-syntax/#Datatype_Restrictions+data DatatypeRestriction =+  DatatypeRestriction {+    datatypeRestrictionDatatype :: Datatype,+    datatypeRestrictionConstraints :: [DatatypeRestriction_Constraint]}+  deriving (Eq, Ord, Read, Show)+_DatatypeRestriction = Core.Name "hydra.owl.syntax.DatatypeRestriction"+_DatatypeRestriction_datatype = Core.Name "datatype"+_DatatypeRestriction_constraints = Core.Name "constraints"+data DatatypeRestriction_Constraint =+  DatatypeRestriction_Constraint {+    datatypeRestriction_ConstraintConstrainingFacet :: DatatypeRestriction_ConstrainingFacet,+    datatypeRestriction_ConstraintRestrictionValue :: Syntax.Literal}+  deriving (Eq, Ord, Read, Show)+_DatatypeRestriction_Constraint = Core.Name "hydra.owl.syntax.DatatypeRestriction_Constraint"+_DatatypeRestriction_Constraint_constrainingFacet = Core.Name "constrainingFacet"+_DatatypeRestriction_Constraint_restrictionValue = Core.Name "restrictionValue"+data DatatypeRestriction_ConstrainingFacet =+  -- | Note: XML Schema constraining facets are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common+  DatatypeRestriction_ConstrainingFacetXmlSchema Schema.ConstrainingFacet |+  DatatypeRestriction_ConstrainingFacetOther Syntax.Iri+  deriving (Eq, Ord, Read, Show)+_DatatypeRestriction_ConstrainingFacet = Core.Name "hydra.owl.syntax.DatatypeRestriction_ConstrainingFacet"+_DatatypeRestriction_ConstrainingFacet_xmlSchema = Core.Name "xmlSchema"+_DatatypeRestriction_ConstrainingFacet_other = Core.Name "other"+data ClassExpression =+  ClassExpressionClass Class |+  ClassExpressionDataSomeValuesFrom DataSomeValuesFrom |+  ClassExpressionDataAllValuesFrom DataAllValuesFrom |+  ClassExpressionDataHasValue DataHasValue |+  ClassExpressionDataMinCardinality DataMinCardinality |+  ClassExpressionDataMaxCardinality DataMaxCardinality |+  ClassExpressionDataExactCardinality DataExactCardinality |+  ClassExpressionObjectAllValuesFrom ObjectAllValuesFrom |+  ClassExpressionObjectExactCardinality ObjectExactCardinality |+  ClassExpressionObjectHasSelf ObjectHasSelf |+  ClassExpressionObjectHasValue ObjectHasValue |+  ClassExpressionObjectIntersectionOf ObjectIntersectionOf |+  ClassExpressionObjectMaxCardinality ObjectMaxCardinality |+  ClassExpressionObjectMinCardinality ObjectMinCardinality |+  ClassExpressionObjectOneOf ObjectOneOf |+  ClassExpressionObjectSomeValuesFrom ObjectSomeValuesFrom |+  ClassExpressionObjectUnionOf ObjectUnionOf+  deriving (Eq, Ord, Read, Show)+_ClassExpression = Core.Name "hydra.owl.syntax.ClassExpression"+_ClassExpression_class = Core.Name "class"+_ClassExpression_dataSomeValuesFrom = Core.Name "dataSomeValuesFrom"+_ClassExpression_dataAllValuesFrom = Core.Name "dataAllValuesFrom"+_ClassExpression_dataHasValue = Core.Name "dataHasValue"+_ClassExpression_dataMinCardinality = Core.Name "dataMinCardinality"+_ClassExpression_dataMaxCardinality = Core.Name "dataMaxCardinality"+_ClassExpression_dataExactCardinality = Core.Name "dataExactCardinality"+_ClassExpression_objectAllValuesFrom = Core.Name "objectAllValuesFrom"+_ClassExpression_objectExactCardinality = Core.Name "objectExactCardinality"+_ClassExpression_objectHasSelf = Core.Name "objectHasSelf"+_ClassExpression_objectHasValue = Core.Name "objectHasValue"+_ClassExpression_objectIntersectionOf = Core.Name "objectIntersectionOf"+_ClassExpression_objectMaxCardinality = Core.Name "objectMaxCardinality"+_ClassExpression_objectMinCardinality = Core.Name "objectMinCardinality"+_ClassExpression_objectOneOf = Core.Name "objectOneOf"+_ClassExpression_objectSomeValuesFrom = Core.Name "objectSomeValuesFrom"+_ClassExpression_objectUnionOf = Core.Name "objectUnionOf"+newtype ObjectIntersectionOf =+  ObjectIntersectionOf {+    unObjectIntersectionOf :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_ObjectIntersectionOf = Core.Name "hydra.owl.syntax.ObjectIntersectionOf"+newtype ObjectUnionOf =+  ObjectUnionOf {+    unObjectUnionOf :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_ObjectUnionOf = Core.Name "hydra.owl.syntax.ObjectUnionOf"+newtype ObjectComplementOf =+  ObjectComplementOf {+    unObjectComplementOf :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectComplementOf = Core.Name "hydra.owl.syntax.ObjectComplementOf"+newtype ObjectOneOf =+  ObjectOneOf {+    unObjectOneOf :: [Individual]}+  deriving (Eq, Ord, Read, Show)+_ObjectOneOf = Core.Name "hydra.owl.syntax.ObjectOneOf"+data ObjectSomeValuesFrom =+  ObjectSomeValuesFrom {+    objectSomeValuesFromProperty :: ObjectPropertyExpression,+    objectSomeValuesFromClass :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectSomeValuesFrom = Core.Name "hydra.owl.syntax.ObjectSomeValuesFrom"+_ObjectSomeValuesFrom_property = Core.Name "property"+_ObjectSomeValuesFrom_class = Core.Name "class"+data ObjectAllValuesFrom =+  ObjectAllValuesFrom {+    objectAllValuesFromProperty :: ObjectPropertyExpression,+    objectAllValuesFromClass :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectAllValuesFrom = Core.Name "hydra.owl.syntax.ObjectAllValuesFrom"+_ObjectAllValuesFrom_property = Core.Name "property"+_ObjectAllValuesFrom_class = Core.Name "class"+data ObjectHasValue =+  ObjectHasValue {+    objectHasValueProperty :: ObjectPropertyExpression,+    objectHasValueIndividual :: Individual}+  deriving (Eq, Ord, Read, Show)+_ObjectHasValue = Core.Name "hydra.owl.syntax.ObjectHasValue"+_ObjectHasValue_property = Core.Name "property"+_ObjectHasValue_individual = Core.Name "individual"+newtype ObjectHasSelf =+  ObjectHasSelf {+    unObjectHasSelf :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectHasSelf = Core.Name "hydra.owl.syntax.ObjectHasSelf"+-- | See https://www.w3.org/TR/owl2-syntax/#Minimum_Cardinality+data ObjectMinCardinality =+  ObjectMinCardinality {+    objectMinCardinalityBound :: Integer,+    objectMinCardinalityProperty :: ObjectPropertyExpression,+    objectMinCardinalityClass :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_ObjectMinCardinality = Core.Name "hydra.owl.syntax.ObjectMinCardinality"+_ObjectMinCardinality_bound = Core.Name "bound"+_ObjectMinCardinality_property = Core.Name "property"+_ObjectMinCardinality_class = Core.Name "class"+-- | See https://www.w3.org/TR/owl2-syntax/#Maximum_Cardinality+data ObjectMaxCardinality =+  ObjectMaxCardinality {+    objectMaxCardinalityBound :: Integer,+    objectMaxCardinalityProperty :: ObjectPropertyExpression,+    objectMaxCardinalityClass :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_ObjectMaxCardinality = Core.Name "hydra.owl.syntax.ObjectMaxCardinality"+_ObjectMaxCardinality_bound = Core.Name "bound"+_ObjectMaxCardinality_property = Core.Name "property"+_ObjectMaxCardinality_class = Core.Name "class"+-- | See https://www.w3.org/TR/owl2-syntax/#Exact_Cardinality+data ObjectExactCardinality =+  ObjectExactCardinality {+    objectExactCardinalityBound :: Integer,+    objectExactCardinalityProperty :: ObjectPropertyExpression,+    objectExactCardinalityClass :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_ObjectExactCardinality = Core.Name "hydra.owl.syntax.ObjectExactCardinality"+_ObjectExactCardinality_bound = Core.Name "bound"+_ObjectExactCardinality_property = Core.Name "property"+_ObjectExactCardinality_class = Core.Name "class"+data DataSomeValuesFrom =+  DataSomeValuesFrom {+    dataSomeValuesFromProperty :: [DataPropertyExpression],+    dataSomeValuesFromRange :: DataRange}+  deriving (Eq, Ord, Read, Show)+_DataSomeValuesFrom = Core.Name "hydra.owl.syntax.DataSomeValuesFrom"+_DataSomeValuesFrom_property = Core.Name "property"+_DataSomeValuesFrom_range = Core.Name "range"+data DataAllValuesFrom =+  DataAllValuesFrom {+    dataAllValuesFromProperty :: [DataPropertyExpression],+    dataAllValuesFromRange :: DataRange}+  deriving (Eq, Ord, Read, Show)+_DataAllValuesFrom = Core.Name "hydra.owl.syntax.DataAllValuesFrom"+_DataAllValuesFrom_property = Core.Name "property"+_DataAllValuesFrom_range = Core.Name "range"+data DataHasValue =+  DataHasValue {+    dataHasValueProperty :: DataPropertyExpression,+    dataHasValueValue :: Syntax.Literal}+  deriving (Eq, Ord, Read, Show)+_DataHasValue = Core.Name "hydra.owl.syntax.DataHasValue"+_DataHasValue_property = Core.Name "property"+_DataHasValue_value = Core.Name "value"+data DataMinCardinality =+  DataMinCardinality {+    dataMinCardinalityBound :: Integer,+    dataMinCardinalityProperty :: DataPropertyExpression,+    dataMinCardinalityRange :: [DataRange]}+  deriving (Eq, Ord, Read, Show)+_DataMinCardinality = Core.Name "hydra.owl.syntax.DataMinCardinality"+_DataMinCardinality_bound = Core.Name "bound"+_DataMinCardinality_property = Core.Name "property"+_DataMinCardinality_range = Core.Name "range"+data DataMaxCardinality =+  DataMaxCardinality {+    dataMaxCardinalityBound :: Integer,+    dataMaxCardinalityProperty :: DataPropertyExpression,+    dataMaxCardinalityRange :: [DataRange]}+  deriving (Eq, Ord, Read, Show)+_DataMaxCardinality = Core.Name "hydra.owl.syntax.DataMaxCardinality"+_DataMaxCardinality_bound = Core.Name "bound"+_DataMaxCardinality_property = Core.Name "property"+_DataMaxCardinality_range = Core.Name "range"+data DataExactCardinality =+  DataExactCardinality {+    dataExactCardinalityBound :: Integer,+    dataExactCardinalityProperty :: DataPropertyExpression,+    dataExactCardinalityRange :: [DataRange]}+  deriving (Eq, Ord, Read, Show)+_DataExactCardinality = Core.Name "hydra.owl.syntax.DataExactCardinality"+_DataExactCardinality_bound = Core.Name "bound"+_DataExactCardinality_property = Core.Name "property"+_DataExactCardinality_range = Core.Name "range"+-- | See https://www.w3.org/TR/owl2-syntax/#Axioms+data Axiom =+  AxiomAnnotationAxiom AnnotationAxiom |+  AxiomAssertion Assertion |+  AxiomClassAxiom ClassAxiom |+  AxiomDataPropertyAxiom DataPropertyAxiom |+  AxiomDatatypeDefinition DatatypeDefinition |+  AxiomDeclaration Declaration |+  AxiomHasKey HasKey |+  AxiomObjectPropertyAxiom ObjectPropertyAxiom+  deriving (Eq, Ord, Read, Show)+_Axiom = Core.Name "hydra.owl.syntax.Axiom"+_Axiom_annotationAxiom = Core.Name "annotationAxiom"+_Axiom_assertion = Core.Name "assertion"+_Axiom_classAxiom = Core.Name "classAxiom"+_Axiom_dataPropertyAxiom = Core.Name "dataPropertyAxiom"+_Axiom_datatypeDefinition = Core.Name "datatypeDefinition"+_Axiom_declaration = Core.Name "declaration"+_Axiom_hasKey = Core.Name "hasKey"+_Axiom_objectPropertyAxiom = Core.Name "objectPropertyAxiom"+data ClassAxiom =+  ClassAxiomDisjointClasses DisjointClasses |+  ClassAxiomDisjointUnion DisjointUnion |+  ClassAxiomEquivalentClasses EquivalentClasses |+  ClassAxiomSubClassOf SubClassOf+  deriving (Eq, Ord, Read, Show)+_ClassAxiom = Core.Name "hydra.owl.syntax.ClassAxiom"+_ClassAxiom_disjointClasses = Core.Name "disjointClasses"+_ClassAxiom_disjointUnion = Core.Name "disjointUnion"+_ClassAxiom_equivalentClasses = Core.Name "equivalentClasses"+_ClassAxiom_subClassOf = Core.Name "subClassOf"+data SubClassOf =+  SubClassOf {+    subClassOfAnnotations :: [Annotation],+    subClassOfSubClass :: ClassExpression,+    subClassOfSuperClass :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_SubClassOf = Core.Name "hydra.owl.syntax.SubClassOf"+_SubClassOf_annotations = Core.Name "annotations"+_SubClassOf_subClass = Core.Name "subClass"+_SubClassOf_superClass = Core.Name "superClass"+data EquivalentClasses =+  EquivalentClasses {+    equivalentClassesAnnotations :: [Annotation],+    equivalentClassesClasses :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_EquivalentClasses = Core.Name "hydra.owl.syntax.EquivalentClasses"+_EquivalentClasses_annotations = Core.Name "annotations"+_EquivalentClasses_classes = Core.Name "classes"+data DisjointClasses =+  DisjointClasses {+    disjointClassesAnnotations :: [Annotation],+    disjointClassesClasses :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_DisjointClasses = Core.Name "hydra.owl.syntax.DisjointClasses"+_DisjointClasses_annotations = Core.Name "annotations"+_DisjointClasses_classes = Core.Name "classes"+-- | See https://www.w3.org/TR/owl2-syntax/#Disjoint_Union_of_Class_Expressions+data DisjointUnion =+  DisjointUnion {+    disjointUnionAnnotations :: [Annotation],+    disjointUnionClass :: Class,+    disjointUnionClasses :: [ClassExpression]}+  deriving (Eq, Ord, Read, Show)+_DisjointUnion = Core.Name "hydra.owl.syntax.DisjointUnion"+_DisjointUnion_annotations = Core.Name "annotations"+_DisjointUnion_class = Core.Name "class"+_DisjointUnion_classes = Core.Name "classes"+data ObjectPropertyAxiom =+  ObjectPropertyAxiomAsymmetricObjectProperty AsymmetricObjectProperty |+  ObjectPropertyAxiomDisjointObjectProperties DisjointObjectProperties |+  ObjectPropertyAxiomEquivalentObjectProperties EquivalentObjectProperties |+  ObjectPropertyAxiomFunctionalObjectProperty FunctionalObjectProperty |+  ObjectPropertyAxiomInverseFunctionalObjectProperty InverseFunctionalObjectProperty |+  ObjectPropertyAxiomInverseObjectProperties InverseObjectProperties |+  ObjectPropertyAxiomIrreflexiveObjectProperty IrreflexiveObjectProperty |+  ObjectPropertyAxiomObjectPropertyDomain ObjectPropertyDomain |+  ObjectPropertyAxiomObjectPropertyRange ObjectPropertyRange |+  ObjectPropertyAxiomReflexiveObjectProperty ReflexiveObjectProperty |+  ObjectPropertyAxiomSubObjectPropertyOf SubObjectPropertyOf |+  ObjectPropertyAxiomSymmetricObjectProperty SymmetricObjectProperty |+  ObjectPropertyAxiomTransitiveObjectProperty TransitiveObjectProperty+  deriving (Eq, Ord, Read, Show)+_ObjectPropertyAxiom = Core.Name "hydra.owl.syntax.ObjectPropertyAxiom"+_ObjectPropertyAxiom_asymmetricObjectProperty = Core.Name "asymmetricObjectProperty"+_ObjectPropertyAxiom_disjointObjectProperties = Core.Name "disjointObjectProperties"+_ObjectPropertyAxiom_equivalentObjectProperties = Core.Name "equivalentObjectProperties"+_ObjectPropertyAxiom_functionalObjectProperty = Core.Name "functionalObjectProperty"+_ObjectPropertyAxiom_inverseFunctionalObjectProperty = Core.Name "inverseFunctionalObjectProperty"+_ObjectPropertyAxiom_inverseObjectProperties = Core.Name "inverseObjectProperties"+_ObjectPropertyAxiom_irreflexiveObjectProperty = Core.Name "irreflexiveObjectProperty"+_ObjectPropertyAxiom_objectPropertyDomain = Core.Name "objectPropertyDomain"+_ObjectPropertyAxiom_objectPropertyRange = Core.Name "objectPropertyRange"+_ObjectPropertyAxiom_reflexiveObjectProperty = Core.Name "reflexiveObjectProperty"+_ObjectPropertyAxiom_subObjectPropertyOf = Core.Name "subObjectPropertyOf"+_ObjectPropertyAxiom_symmetricObjectProperty = Core.Name "symmetricObjectProperty"+_ObjectPropertyAxiom_transitiveObjectProperty = Core.Name "transitiveObjectProperty"+data SubObjectPropertyOf =+  SubObjectPropertyOf {+    subObjectPropertyOfAnnotations :: [Annotation],+    subObjectPropertyOfSubProperty :: [ObjectPropertyExpression],+    subObjectPropertyOfSuperProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_SubObjectPropertyOf = Core.Name "hydra.owl.syntax.SubObjectPropertyOf"+_SubObjectPropertyOf_annotations = Core.Name "annotations"+_SubObjectPropertyOf_subProperty = Core.Name "subProperty"+_SubObjectPropertyOf_superProperty = Core.Name "superProperty"+data EquivalentObjectProperties =+  EquivalentObjectProperties {+    equivalentObjectPropertiesAnnotations :: [Annotation],+    equivalentObjectPropertiesProperties :: [ObjectPropertyExpression]}+  deriving (Eq, Ord, Read, Show)+_EquivalentObjectProperties = Core.Name "hydra.owl.syntax.EquivalentObjectProperties"+_EquivalentObjectProperties_annotations = Core.Name "annotations"+_EquivalentObjectProperties_properties = Core.Name "properties"+data DisjointObjectProperties =+  DisjointObjectProperties {+    disjointObjectPropertiesAnnotations :: [Annotation],+    disjointObjectPropertiesProperties :: [ObjectPropertyExpression]}+  deriving (Eq, Ord, Read, Show)+_DisjointObjectProperties = Core.Name "hydra.owl.syntax.DisjointObjectProperties"+_DisjointObjectProperties_annotations = Core.Name "annotations"+_DisjointObjectProperties_properties = Core.Name "properties"+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Domain+data ObjectPropertyDomain =+  ObjectPropertyDomain {+    objectPropertyDomainAnnotations :: [Annotation],+    objectPropertyDomainProperty :: ObjectPropertyExpression,+    objectPropertyDomainDomain :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectPropertyDomain = Core.Name "hydra.owl.syntax.ObjectPropertyDomain"+_ObjectPropertyDomain_annotations = Core.Name "annotations"+_ObjectPropertyDomain_property = Core.Name "property"+_ObjectPropertyDomain_domain = Core.Name "domain"+-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Range+data ObjectPropertyRange =+  ObjectPropertyRange {+    objectPropertyRangeAnnotations :: [Annotation],+    objectPropertyRangeProperty :: ObjectPropertyExpression,+    objectPropertyRangeRange :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_ObjectPropertyRange = Core.Name "hydra.owl.syntax.ObjectPropertyRange"+_ObjectPropertyRange_annotations = Core.Name "annotations"+_ObjectPropertyRange_property = Core.Name "property"+_ObjectPropertyRange_range = Core.Name "range"+data InverseObjectProperties =+  InverseObjectProperties {+    inverseObjectPropertiesAnnotations :: [Annotation],+    inverseObjectPropertiesProperty1 :: ObjectPropertyExpression,+    inverseObjectPropertiesProperty2 :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_InverseObjectProperties = Core.Name "hydra.owl.syntax.InverseObjectProperties"+_InverseObjectProperties_annotations = Core.Name "annotations"+_InverseObjectProperties_property1 = Core.Name "property1"+_InverseObjectProperties_property2 = Core.Name "property2"+data FunctionalObjectProperty =+  FunctionalObjectProperty {+    functionalObjectPropertyAnnotations :: [Annotation],+    functionalObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_FunctionalObjectProperty = Core.Name "hydra.owl.syntax.FunctionalObjectProperty"+_FunctionalObjectProperty_annotations = Core.Name "annotations"+_FunctionalObjectProperty_property = Core.Name "property"+data InverseFunctionalObjectProperty =+  InverseFunctionalObjectProperty {+    inverseFunctionalObjectPropertyAnnotations :: [Annotation],+    inverseFunctionalObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_InverseFunctionalObjectProperty = Core.Name "hydra.owl.syntax.InverseFunctionalObjectProperty"+_InverseFunctionalObjectProperty_annotations = Core.Name "annotations"+_InverseFunctionalObjectProperty_property = Core.Name "property"+data ReflexiveObjectProperty =+  ReflexiveObjectProperty {+    reflexiveObjectPropertyAnnotations :: [Annotation],+    reflexiveObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_ReflexiveObjectProperty = Core.Name "hydra.owl.syntax.ReflexiveObjectProperty"+_ReflexiveObjectProperty_annotations = Core.Name "annotations"+_ReflexiveObjectProperty_property = Core.Name "property"+data IrreflexiveObjectProperty =+  IrreflexiveObjectProperty {+    irreflexiveObjectPropertyAnnotations :: [Annotation],+    irreflexiveObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_IrreflexiveObjectProperty = Core.Name "hydra.owl.syntax.IrreflexiveObjectProperty"+_IrreflexiveObjectProperty_annotations = Core.Name "annotations"+_IrreflexiveObjectProperty_property = Core.Name "property"+data SymmetricObjectProperty =+  SymmetricObjectProperty {+    symmetricObjectPropertyAnnotations :: [Annotation],+    symmetricObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_SymmetricObjectProperty = Core.Name "hydra.owl.syntax.SymmetricObjectProperty"+_SymmetricObjectProperty_annotations = Core.Name "annotations"+_SymmetricObjectProperty_property = Core.Name "property"+data AsymmetricObjectProperty =+  AsymmetricObjectProperty {+    asymmetricObjectPropertyAnnotations :: [Annotation],+    asymmetricObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_AsymmetricObjectProperty = Core.Name "hydra.owl.syntax.AsymmetricObjectProperty"+_AsymmetricObjectProperty_annotations = Core.Name "annotations"+_AsymmetricObjectProperty_property = Core.Name "property"+data TransitiveObjectProperty =+  TransitiveObjectProperty {+    transitiveObjectPropertyAnnotations :: [Annotation],+    transitiveObjectPropertyProperty :: ObjectPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_TransitiveObjectProperty = Core.Name "hydra.owl.syntax.TransitiveObjectProperty"+_TransitiveObjectProperty_annotations = Core.Name "annotations"+_TransitiveObjectProperty_property = Core.Name "property"+data DataPropertyAxiom =+  DataPropertyAxiomDataPropertyAxiom DataPropertyAxiom |+  DataPropertyAxiomDataPropertyRange DataPropertyRange |+  DataPropertyAxiomDisjointDataProperties DisjointDataProperties |+  DataPropertyAxiomEquivalentDataProperties EquivalentDataProperties |+  DataPropertyAxiomFunctionalDataProperty FunctionalDataProperty |+  DataPropertyAxiomSubDataPropertyOf SubDataPropertyOf+  deriving (Eq, Ord, Read, Show)+_DataPropertyAxiom = Core.Name "hydra.owl.syntax.DataPropertyAxiom"+_DataPropertyAxiom_dataPropertyAxiom = Core.Name "dataPropertyAxiom"+_DataPropertyAxiom_dataPropertyRange = Core.Name "dataPropertyRange"+_DataPropertyAxiom_disjointDataProperties = Core.Name "disjointDataProperties"+_DataPropertyAxiom_equivalentDataProperties = Core.Name "equivalentDataProperties"+_DataPropertyAxiom_functionalDataProperty = Core.Name "functionalDataProperty"+_DataPropertyAxiom_subDataPropertyOf = Core.Name "subDataPropertyOf"+data SubDataPropertyOf =+  SubDataPropertyOf {+    subDataPropertyOfAnnotations :: [Annotation],+    subDataPropertyOfSubProperty :: DataPropertyExpression,+    subDataPropertyOfSuperProperty :: DataPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_SubDataPropertyOf = Core.Name "hydra.owl.syntax.SubDataPropertyOf"+_SubDataPropertyOf_annotations = Core.Name "annotations"+_SubDataPropertyOf_subProperty = Core.Name "subProperty"+_SubDataPropertyOf_superProperty = Core.Name "superProperty"+data EquivalentDataProperties =+  EquivalentDataProperties {+    equivalentDataPropertiesAnnotations :: [Annotation],+    equivalentDataPropertiesProperties :: [DataPropertyExpression]}+  deriving (Eq, Ord, Read, Show)+_EquivalentDataProperties = Core.Name "hydra.owl.syntax.EquivalentDataProperties"+_EquivalentDataProperties_annotations = Core.Name "annotations"+_EquivalentDataProperties_properties = Core.Name "properties"+data DisjointDataProperties =+  DisjointDataProperties {+    disjointDataPropertiesAnnotations :: [Annotation],+    disjointDataPropertiesProperties :: [DataPropertyExpression]}+  deriving (Eq, Ord, Read, Show)+_DisjointDataProperties = Core.Name "hydra.owl.syntax.DisjointDataProperties"+_DisjointDataProperties_annotations = Core.Name "annotations"+_DisjointDataProperties_properties = Core.Name "properties"+data DataPropertyDomain =+  DataPropertyDomain {+    dataPropertyDomainAnnotations :: [Annotation],+    dataPropertyDomainProperty :: DataPropertyExpression,+    dataPropertyDomainDomain :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_DataPropertyDomain = Core.Name "hydra.owl.syntax.DataPropertyDomain"+_DataPropertyDomain_annotations = Core.Name "annotations"+_DataPropertyDomain_property = Core.Name "property"+_DataPropertyDomain_domain = Core.Name "domain"+data DataPropertyRange =+  DataPropertyRange {+    dataPropertyRangeAnnotations :: [Annotation],+    dataPropertyRangeProperty :: DataPropertyExpression,+    dataPropertyRangeRange :: ClassExpression}+  deriving (Eq, Ord, Read, Show)+_DataPropertyRange = Core.Name "hydra.owl.syntax.DataPropertyRange"+_DataPropertyRange_annotations = Core.Name "annotations"+_DataPropertyRange_property = Core.Name "property"+_DataPropertyRange_range = Core.Name "range"+data FunctionalDataProperty =+  FunctionalDataProperty {+    functionalDataPropertyAnnotations :: [Annotation],+    functionalDataPropertyProperty :: DataPropertyExpression}+  deriving (Eq, Ord, Read, Show)+_FunctionalDataProperty = Core.Name "hydra.owl.syntax.FunctionalDataProperty"+_FunctionalDataProperty_annotations = Core.Name "annotations"+_FunctionalDataProperty_property = Core.Name "property"+data DatatypeDefinition =+  DatatypeDefinition {+    datatypeDefinitionAnnotations :: [Annotation],+    datatypeDefinitionDatatype :: Datatype,+    datatypeDefinitionRange :: DataRange}+  deriving (Eq, Ord, Read, Show)+_DatatypeDefinition = Core.Name "hydra.owl.syntax.DatatypeDefinition"+_DatatypeDefinition_annotations = Core.Name "annotations"+_DatatypeDefinition_datatype = Core.Name "datatype"+_DatatypeDefinition_range = Core.Name "range"+-- | See https://www.w3.org/TR/owl2-syntax/#Keys+data HasKey =+  HasKey {+    hasKeyAnnotations :: [Annotation],+    hasKeyClass :: ClassExpression,+    hasKeyObjectProperties :: [ObjectPropertyExpression],+    hasKeyDataProperties :: [DataPropertyExpression]}+  deriving (Eq, Ord, Read, Show)+_HasKey = Core.Name "hydra.owl.syntax.HasKey"+_HasKey_annotations = Core.Name "annotations"+_HasKey_class = Core.Name "class"+_HasKey_objectProperties = Core.Name "objectProperties"+_HasKey_dataProperties = Core.Name "dataProperties"+data Assertion =+  AssertionClassAssertion ClassAssertion |+  AssertionDataPropertyAssertion DataPropertyAssertion |+  AssertionDifferentIndividuals DifferentIndividuals |+  AssertionObjectPropertyAssertion ObjectPropertyAssertion |+  AssertionNegativeDataPropertyAssertion NegativeDataPropertyAssertion |+  AssertionNegativeObjectPropertyAssertion NegativeObjectPropertyAssertion |+  AssertionSameIndividual SameIndividual+  deriving (Eq, Ord, Read, Show)+_Assertion = Core.Name "hydra.owl.syntax.Assertion"+_Assertion_classAssertion = Core.Name "classAssertion"+_Assertion_dataPropertyAssertion = Core.Name "dataPropertyAssertion"+_Assertion_differentIndividuals = Core.Name "differentIndividuals"+_Assertion_objectPropertyAssertion = Core.Name "objectPropertyAssertion"+_Assertion_negativeDataPropertyAssertion = Core.Name "negativeDataPropertyAssertion"+_Assertion_negativeObjectPropertyAssertion = Core.Name "negativeObjectPropertyAssertion"+_Assertion_sameIndividual = Core.Name "sameIndividual"+data SameIndividual =+  SameIndividual {+    sameIndividualAnnotations :: [Annotation],+    sameIndividualIndividuals :: [Individual]}+  deriving (Eq, Ord, Read, Show)+_SameIndividual = Core.Name "hydra.owl.syntax.SameIndividual"+_SameIndividual_annotations = Core.Name "annotations"+_SameIndividual_individuals = Core.Name "individuals"+data DifferentIndividuals =+  DifferentIndividuals {+    differentIndividualsAnnotations :: [Annotation],+    differentIndividualsIndividuals :: [Individual]}+  deriving (Eq, Ord, Read, Show)+_DifferentIndividuals = Core.Name "hydra.owl.syntax.DifferentIndividuals"+_DifferentIndividuals_annotations = Core.Name "annotations"+_DifferentIndividuals_individuals = Core.Name "individuals"+data ClassAssertion =+  ClassAssertion {+    classAssertionAnnotations :: [Annotation],+    classAssertionClass :: ClassExpression,+    classAssertionIndividual :: Individual}+  deriving (Eq, Ord, Read, Show)+_ClassAssertion = Core.Name "hydra.owl.syntax.ClassAssertion"+_ClassAssertion_annotations = Core.Name "annotations"+_ClassAssertion_class = Core.Name "class"+_ClassAssertion_individual = Core.Name "individual"+data ObjectPropertyAssertion =+  ObjectPropertyAssertion {+    objectPropertyAssertionAnnotations :: [Annotation],+    objectPropertyAssertionProperty :: ObjectPropertyExpression,+    objectPropertyAssertionSource :: Individual,+    objectPropertyAssertionTarget :: Individual}+  deriving (Eq, Ord, Read, Show)+_ObjectPropertyAssertion = Core.Name "hydra.owl.syntax.ObjectPropertyAssertion"+_ObjectPropertyAssertion_annotations = Core.Name "annotations"+_ObjectPropertyAssertion_property = Core.Name "property"+_ObjectPropertyAssertion_source = Core.Name "source"+_ObjectPropertyAssertion_target = Core.Name "target"+data NegativeObjectPropertyAssertion =+  NegativeObjectPropertyAssertion {+    negativeObjectPropertyAssertionAnnotations :: [Annotation],+    negativeObjectPropertyAssertionProperty :: ObjectPropertyExpression,+    negativeObjectPropertyAssertionSource :: Individual,+    negativeObjectPropertyAssertionTarget :: Individual}+  deriving (Eq, Ord, Read, Show)+_NegativeObjectPropertyAssertion = Core.Name "hydra.owl.syntax.NegativeObjectPropertyAssertion"+_NegativeObjectPropertyAssertion_annotations = Core.Name "annotations"+_NegativeObjectPropertyAssertion_property = Core.Name "property"+_NegativeObjectPropertyAssertion_source = Core.Name "source"+_NegativeObjectPropertyAssertion_target = Core.Name "target"+data DataPropertyAssertion =+  DataPropertyAssertion {+    dataPropertyAssertionAnnotations :: [Annotation],+    dataPropertyAssertionProperty :: DataPropertyExpression,+    dataPropertyAssertionSource :: Individual,+    dataPropertyAssertionTarget :: Individual}+  deriving (Eq, Ord, Read, Show)+_DataPropertyAssertion = Core.Name "hydra.owl.syntax.DataPropertyAssertion"+_DataPropertyAssertion_annotations = Core.Name "annotations"+_DataPropertyAssertion_property = Core.Name "property"+_DataPropertyAssertion_source = Core.Name "source"+_DataPropertyAssertion_target = Core.Name "target"+data NegativeDataPropertyAssertion =+  NegativeDataPropertyAssertion {+    negativeDataPropertyAssertionAnnotations :: [Annotation],+    negativeDataPropertyAssertionProperty :: DataPropertyExpression,+    negativeDataPropertyAssertionSource :: Individual,+    negativeDataPropertyAssertionTarget :: Individual}+  deriving (Eq, Ord, Read, Show)+_NegativeDataPropertyAssertion = Core.Name "hydra.owl.syntax.NegativeDataPropertyAssertion"+_NegativeDataPropertyAssertion_annotations = Core.Name "annotations"+_NegativeDataPropertyAssertion_property = Core.Name "property"+_NegativeDataPropertyAssertion_source = Core.Name "source"+_NegativeDataPropertyAssertion_target = Core.Name "target"

@@ -0,0 +1,140 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Serialization functions for converting RDF graphs to N-Triples format expressions++module Hydra.Rdf.Serde where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Relational as Relational+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+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+-- | Convert a blank node to an expression+blankNodeToExpr :: Syntax.BlankNode -> Ast.Expr+blankNodeToExpr bnode =+    Serialization.noSep [+      Serialization.cst "_:",+      (Serialization.cst (Syntax.unBlankNode bnode))]+-- | Escape a single IRI character code to a string+escapeIriChar :: Int -> String+escapeIriChar c =+    Logic.ifElse (Logic.or (Equality.lte c 32) (Logic.or (Equality.equal c 60) (Logic.or (Equality.equal c 62) (Logic.or (Equality.equal c 34) (Logic.or (Equality.equal c 123) (Logic.or (Equality.equal c 125) (Logic.or (Equality.equal c 124) (Logic.or (Equality.equal c 94) (Logic.or (Equality.equal c 96) (Equality.equal c 92)))))))))) (uchar4 c) (Strings.fromList [+      c])+-- | Escape a string for use in an N-Triples IRI. Disallowed characters are emitted as 4-digit UCHAR escapes.+escapeIriStr :: String -> String+escapeIriStr s = Strings.cat (Lists.map escapeIriChar (Strings.toList s))+-- | Escape a single literal character code to a string+escapeLiteralChar :: Int -> String+escapeLiteralChar c =+    Logic.ifElse (Equality.equal c 34) "\\\"" (Logic.ifElse (Equality.equal c 92) "\\\\" (Logic.ifElse (Equality.equal c 10) "\\n" (Logic.ifElse (Equality.equal c 13) "\\r" (Strings.fromList [+      c]))))+-- | Escape a string for use in an N-Triples literal+escapeLiteralString :: String -> String+escapeLiteralString s = Strings.cat (Lists.map escapeLiteralChar (Strings.toList s))+-- | Convert an RDF graph to an expression+graphToExpr :: Syntax.Graph -> Ast.Expr+graphToExpr g = Serialization.newlineSep (Lists.map tripleToExpr (Sets.toList (Syntax.unGraph g)))+-- | Convert a value 0-15 to an uppercase hex digit code point+hexDigit :: Int -> Int+hexDigit n = Logic.ifElse (Equality.lt n 10) (Math.add n 48) (Math.add (Math.sub n 10) 65)+-- | Convert an IRI to an expression+iriToExpr :: Syntax.Iri -> Ast.Expr+iriToExpr iri =+    Serialization.noSep [+      Serialization.cst "<",+      (Serialization.cst (escapeIriStr (Syntax.unIri iri))),+      (Serialization.cst ">")]+-- | Convert a language tag to an expression+languageTagToExpr :: Syntax.LanguageTag -> Ast.Expr+languageTagToExpr lang =+    Serialization.noSep [+      Serialization.cst "@",+      (Serialization.cst (Syntax.unLanguageTag lang))]+-- | Convert a literal to an expression+literalToExpr :: Syntax.Literal -> Ast.Expr+literalToExpr lit =++      let lex = Syntax.literalLexicalForm lit+          dt = Syntax.literalDatatypeIri lit+          lang = Syntax.literalLanguageTag lit+          lexExpr =+                  Serialization.cst (Strings.cat [+                    "\"",+                    (escapeLiteralString lex),+                    "\""])+          suffix =+                  Optionals.cases lang (Serialization.noSep [+                    Serialization.cst "^^",+                    (iriToExpr dt)]) languageTagToExpr+      in (Serialization.noSep [+        lexExpr,+        suffix])+-- | Convert a node to an expression+nodeToExpr :: Syntax.Node -> Ast.Expr+nodeToExpr n =+    case n of+      Syntax.NodeIri v0 -> iriToExpr v0+      Syntax.NodeBnode v0 -> blankNodeToExpr v0+      Syntax.NodeLiteral v0 -> literalToExpr v0+-- | Convert an RDF graph to an N-Triples string+rdfGraphToNtriples :: Syntax.Graph -> String+rdfGraphToNtriples g = Serialization.printExpr (graphToExpr g)+-- | Convert a resource to an expression+resourceToExpr :: Syntax.Resource -> Ast.Expr+resourceToExpr r =+    case r of+      Syntax.ResourceIri v0 -> iriToExpr v0+      Syntax.ResourceBnode v0 -> blankNodeToExpr v0+-- | Convert a triple to an expression+tripleToExpr :: Syntax.Triple -> Ast.Expr+tripleToExpr t =++      let subj = Syntax.tripleSubject t+          pred = Syntax.triplePredicate t+          obj = Syntax.tripleObject t+      in (Serialization.spaceSep [+        resourceToExpr subj,+        (iriToExpr pred),+        (nodeToExpr obj),+        (Serialization.cst ".")])+-- | Format a code point as a 4-digit UCHAR escape sequence+uchar4 :: Int -> String+uchar4 c =++      let d3 = Optionals.fromOptional 0 (Math.maybeDiv c 4096)+          r3 = Optionals.fromOptional 0 (Math.maybeMod c 4096)+          d2 = Optionals.fromOptional 0 (Math.maybeDiv r3 256)+          r2 = Optionals.fromOptional 0 (Math.maybeMod r3 256)+          d1 = Optionals.fromOptional 0 (Math.maybeDiv r2 16)+          d0 = Optionals.fromOptional 0 (Math.maybeMod r2 16)+      in (Strings.cat2 "\\u" (Strings.fromList [+        hexDigit d3,+        (hexDigit d2),+        (hexDigit d1),+        (hexDigit d0)]))

@@ -0,0 +1,132 @@+-- Note: this is an automatically generated file. Do not edit.+-- | An RDF 1.1 syntax model++module Hydra.Rdf.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+import qualified Data.Map as M+import qualified Data.Set as S+newtype BlankNode =+  BlankNode {+    unBlankNode :: String}+  deriving (Eq, Ord, Read, Show)+_BlankNode = Core.Name "hydra.rdf.syntax.BlankNode"+-- | Stand-in for rdfs:Class+newtype RdfsClass =+  RdfsClass {+    unRdfsClass :: ()}+  deriving (Eq, Ord, Read, Show)+_RdfsClass = Core.Name "hydra.rdf.syntax.RdfsClass"+newtype Dataset =+  Dataset {+    unDataset :: (S.Set Quad)}+  deriving (Eq, Ord, Read, Show)+_Dataset = Core.Name "hydra.rdf.syntax.Dataset"+-- | A graph of RDF statements together with a distinguished subject and/or object node+data Description =+  Description {+    descriptionSubject :: Node,+    descriptionGraph :: Graph}+  deriving (Eq, Ord, Read, Show)+_Description = Core.Name "hydra.rdf.syntax.Description"+_Description_subject = Core.Name "subject"+_Description_graph = Core.Name "graph"+newtype Graph =+  Graph {+    unGraph :: (S.Set Triple)}+  deriving (Eq, Ord, Read, Show)+_Graph = Core.Name "hydra.rdf.syntax.Graph"+-- | An Internationalized Resource Identifier+newtype Iri =+  Iri {+    unIri :: String}+  deriving (Eq, Ord, Read, Show)+_Iri = Core.Name "hydra.rdf.syntax.Iri"+-- | An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes+data IriOrLiteral =+  IriOrLiteralIri Iri |+  IriOrLiteralLiteral Literal+  deriving (Eq, Ord, Read, Show)+_IriOrLiteral = Core.Name "hydra.rdf.syntax.IriOrLiteral"+_IriOrLiteral_iri = Core.Name "iri"+_IriOrLiteral_literal = Core.Name "literal"+-- | A convenience type which provides at most one string value per language, and optionally a value without a language+newtype LangStrings =+  LangStrings {+    unLangStrings :: (M.Map (Maybe LanguageTag) String)}+  deriving (Eq, Ord, Read, Show)+_LangStrings = Core.Name "hydra.rdf.syntax.LangStrings"+-- | A BCP47 language tag+newtype LanguageTag =+  LanguageTag {+    unLanguageTag :: String}+  deriving (Eq, Ord, Read, Show)+_LanguageTag = Core.Name "hydra.rdf.syntax.LanguageTag"+-- | A value such as a string, number, or date+data Literal =+  Literal {+    -- | a Unicode string, which should be in Normal Form C+    literalLexicalForm :: String,+    -- | an IRI identifying a datatype that determines how the lexical form maps to a literal value+    literalDatatypeIri :: Iri,+    -- | An optional language tag, present if and only if the datatype IRI is http://www.w3.org/1999/02/22-rdf-syntax-ns#langString+    literalLanguageTag :: (Maybe LanguageTag)}+  deriving (Eq, Ord, Read, Show)+_Literal = Core.Name "hydra.rdf.syntax.Literal"+_Literal_lexicalForm = Core.Name "lexicalForm"+_Literal_datatypeIri = Core.Name "datatypeIri"+_Literal_languageTag = Core.Name "languageTag"+data Node =+  NodeIri Iri |+  NodeBnode BlankNode |+  NodeLiteral Literal+  deriving (Eq, Ord, Read, Show)+_Node = Core.Name "hydra.rdf.syntax.Node"+_Node_iri = Core.Name "iri"+_Node_bnode = Core.Name "bnode"+_Node_literal = Core.Name "literal"+-- | A type representing an RDF property, and encapsulating its domain, range, and subclass relationships+data Property =+  Property {+    -- | State that any resource that has a given property is an instance of one or more classes+    propertyDomain :: (S.Set RdfsClass),+    -- | States that the values of a property are instances of one or more classes+    propertyRange :: (S.Set RdfsClass),+    propertySubPropertyOf :: (S.Set Property)}+  deriving (Eq, Ord, Read, Show)+_Property = Core.Name "hydra.rdf.syntax.Property"+_Property_domain = Core.Name "domain"+_Property_range = Core.Name "range"+_Property_subPropertyOf = Core.Name "subPropertyOf"+-- | An RDF triple with an optional named graph component+data Quad =+  Quad {+    quadSubject :: Resource,+    quadPredicate :: Iri,+    quadObject :: Node,+    quadGraph :: (Maybe Iri)}+  deriving (Eq, Ord, Read, Show)+_Quad = Core.Name "hydra.rdf.syntax.Quad"+_Quad_subject = Core.Name "subject"+_Quad_predicate = Core.Name "predicate"+_Quad_object = Core.Name "object"+_Quad_graph = Core.Name "graph"+data Resource =+  ResourceIri Iri |+  ResourceBnode BlankNode+  deriving (Eq, Ord, Read, Show)+_Resource = Core.Name "hydra.rdf.syntax.Resource"+_Resource_iri = Core.Name "iri"+_Resource_bnode = Core.Name "bnode"+-- | An RDF triple defined by a subject, predicate, and object+data Triple =+  Triple {+    tripleSubject :: Resource,+    triplePredicate :: Iri,+    tripleObject :: Node}+  deriving (Eq, Ord, Read, Show)+_Triple = Core.Name "hydra.rdf.syntax.Triple"+_Triple_subject = Core.Name "subject"+_Triple_predicate = Core.Name "predicate"+_Triple_object = Core.Name "object"

@@ -0,0 +1,170 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utility functions for working with RDF graphs and descriptions++module Hydra.Rdf.Utils where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+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+-- | Convert a list of descriptions to an RDF graph+descriptionsToGraph :: [Syntax.Description] -> Syntax.Graph+descriptionsToGraph ds = Syntax.Graph (Sets.fromList (triplesOf ds))+-- | Create an empty description with a given node+emptyDescription :: Syntax.Node -> Syntax.Description+emptyDescription node =+    Syntax.Description {+      Syntax.descriptionSubject = node,+      Syntax.descriptionGraph = emptyRdfGraph}+-- | An empty LangStrings value+emptyLangStrings :: Syntax.LangStrings+emptyLangStrings = Syntax.LangStrings Maps.empty+-- | An empty RDF graph+emptyRdfGraph :: Syntax.Graph+emptyRdfGraph = Syntax.Graph Sets.empty+-- | Encode a Hydra literal as an RDF literal+encodeLiteral :: Core.Literal -> Syntax.Literal+encodeLiteral lit =+    case lit of+      Core.LiteralBinary v0 -> Syntax.Literal {+        Syntax.literalLexicalForm = (Literals.binaryToString v0),+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "base64Binary"),+        Syntax.literalLanguageTag = Nothing}+      Core.LiteralBoolean v0 -> Syntax.Literal {+        Syntax.literalLexicalForm = (Logic.ifElse v0 "true" "false"),+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "boolean"),+        Syntax.literalLanguageTag = Nothing}+      Core.LiteralFloat v0 -> case v0 of+        Core.FloatValueFloat32 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showFloat32 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "float"),+          Syntax.literalLanguageTag = Nothing}+        Core.FloatValueFloat64 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showFloat64 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "double"),+          Syntax.literalLanguageTag = Nothing}+      Core.LiteralInteger v0 -> case v0 of+        Core.IntegerValueBigint v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showBigint v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "integer"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueInt8 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showInt8 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "byte"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueInt16 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showInt16 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "short"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueInt32 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showInt32 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "int"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueInt64 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showInt64 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "long"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueUint8 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showUint8 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedByte"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueUint16 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showUint16 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedShort"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueUint32 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showUint32 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedInt"),+          Syntax.literalLanguageTag = Nothing}+        Core.IntegerValueUint64 v1 -> Syntax.Literal {+          Syntax.literalLexicalForm = (Literals.showUint64 v1),+          Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "unsignedLong"),+          Syntax.literalLanguageTag = Nothing}+      Core.LiteralString v0 -> Syntax.Literal {+        Syntax.literalLexicalForm = v0,+        Syntax.literalDatatypeIri = (xmlSchemaDatatypeIri "string"),+        Syntax.literalLanguageTag = Nothing}+-- | Create triples from a subject, predicate, and list of object nodes+forObjects :: Syntax.Resource -> Syntax.Iri -> [Syntax.Node] -> [Syntax.Triple]+forObjects subj pred objs =+    Lists.map (\obj -> Syntax.Triple {+      Syntax.tripleSubject = subj,+      Syntax.triplePredicate = pred,+      Syntax.tripleObject = obj}) objs+-- | Construct an IRI from a namespace and local name+iri :: String -> String -> Syntax.Iri+iri ns local = Syntax.Iri (Strings.cat2 ns local)+-- | Construct a key IRI from a local name+keyIri :: String -> Syntax.Iri+keyIri local = iri "urn:key:" local+-- | Merge a list of RDF graphs into a single graph+mergeGraphs :: [Syntax.Graph] -> Syntax.Graph+mergeGraphs graphs = Syntax.Graph (Sets.unions (Lists.map Syntax.unGraph graphs))+-- | Convert a Hydra name to an RDF IRI+nameToIri :: Core.Name -> Syntax.Iri+nameToIri name = Syntax.Iri (Strings.cat2 "urn:" (Core.unName name))+-- | Generate the next blank node and an incremented counter+nextBlankNode :: Int -> (Syntax.Resource, Int)+nextBlankNode counter =+    (Syntax.ResourceBnode (Syntax.BlankNode (Strings.cat2 "b" (Literals.showInt32 counter))), (Math.add counter 1))+-- | Construct a property IRI from a record name and field name+propertyIri :: Core.Name -> Core.Name -> Syntax.Iri+propertyIri rname fname =++      let qualName = Names.qualifyName rname+          gname = Util.qualifiedNameModuleName qualName+          local_ = Util.qualifiedNameLocal qualName+      in (Syntax.Iri (Strings.cat [+        "urn:",+        (Optionals.cases gname "" Packaging.unModuleName),+        "#",+        (Formatting.decapitalize local_),+        (Formatting.capitalize (Core.unName fname))]))+-- | Construct an RDF namespace IRI+rdfIri :: String -> Syntax.Iri+rdfIri local = iri "http://www.w3.org/1999/02/22-rdf-syntax-ns#" local+-- | Convert a resource to a node+resourceToNode :: Syntax.Resource -> Syntax.Node+resourceToNode r =+    case r of+      Syntax.ResourceIri v0 -> Syntax.NodeIri v0+      Syntax.ResourceBnode v0 -> Syntax.NodeBnode v0+-- | Extract subjects from a list of descriptions+subjectsOf :: [Syntax.Description] -> [Syntax.Node]+subjectsOf descs = Lists.map Syntax.descriptionSubject descs+-- | Extract all triples from a list of descriptions+triplesOf :: [Syntax.Description] -> [Syntax.Triple]+triplesOf descs = Lists.concat (Lists.map (\d -> Sets.toList (Syntax.unGraph (Syntax.descriptionGraph d))) descs)+-- | Construct an XML Schema datatype IRI+xmlSchemaDatatypeIri :: String -> Syntax.Iri+xmlSchemaDatatypeIri local = iri "http://www.w3.org/2001/XMLSchema#" local

@@ -0,0 +1,317 @@+-- Note: this is an automatically generated file. Do not edit.+-- | SHACL coder: converts Hydra types and terms to SHACL shapes and RDF descriptions++module Hydra.Shacl.Coder where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Extract.Core as ExtractCore+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as JsonModel+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Rdf.Syntax as Syntax+import qualified Hydra.Rdf.Utils as Utils+import qualified Hydra.Relational as Relational+import qualified Hydra.Shacl.Model as ShaclModel+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+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+-- | Construct CommonProperties from a list of constraints, using defaults for other fields+common :: [ShaclModel.CommonConstraint] -> ShaclModel.CommonProperties+common constraints =+    ShaclModel.CommonProperties {+      ShaclModel.commonPropertiesConstraints = (Sets.fromList constraints),+      ShaclModel.commonPropertiesDeactivated = Nothing,+      ShaclModel.commonPropertiesMessage = (Syntax.LangStrings Maps.empty),+      ShaclModel.commonPropertiesSeverity = ShaclModel.SeverityInfo,+      ShaclModel.commonPropertiesTargetClass = Sets.empty,+      ShaclModel.commonPropertiesTargetNode = Sets.empty,+      ShaclModel.commonPropertiesTargetObjectsOf = Sets.empty,+      ShaclModel.commonPropertiesTargetSubjectsOf = Sets.empty}+-- | Default CommonProperties with empty constraints and default severity+defaultCommonProperties :: ShaclModel.CommonProperties+defaultCommonProperties = common []+-- | Convert a binding's name to an RDF IRI+elementIri :: Core.Binding -> Syntax.Iri+elementIri el = Utils.nameToIri (Core.bindingName el)+-- | Encode a record field as RDF triples with a given subject+encodeField :: Core.Name -> Syntax.Resource -> Core.Field -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Triple], Int)+encodeField rname subject field cx g =++      let pair1 = Utils.nextBlankNode cx+          node = Pairs.first pair1+          cx1 = Pairs.second pair1+      in (Eithers.bind (encodeTerm node (Core.fieldTerm field) cx1 g) (\_r1 ->+        let descs = Pairs.first _r1+            cx2 = Pairs.second _r1+        in (Right (+          Lists.concat2 (Utils.triplesOf descs) (Utils.forObjects subject (Utils.propertyIri rname (Core.fieldName field)) (Utils.subjectsOf descs)),+          cx2))))+-- | Encode a FieldType as a SHACL property shape Definition+encodeFieldType :: Core.Name -> Maybe Integer -> Core.FieldType -> t0 -> Either Errors.Error (ShaclModel.Definition ShaclModel.PropertyShape)+encodeFieldType rname order ft cx =++      let fname = Core.fieldTypeName ft+          ftype = Core.fieldTypeType ft+          iri = Utils.propertyIri rname fname+          forType =+                  \mn -> \mx -> \t -> case (Strip.deannotateType t) of+                    Core.TypeOptional v0 -> forType (Just 0) mx v0+                    Core.TypeSet v0 -> forType mn Nothing v0+                    _ -> forTypeDefault mn mx t+          forTypeDefault =+                  \mn -> \mx -> \t -> Eithers.map (\_cp ->+                    let baseProp = property iri+                        minC = Optionals.map (\_n -> ShaclModel.PropertyShapeConstraintMinCount _n) mn+                        maxC = Optionals.map (\_n -> ShaclModel.PropertyShapeConstraintMaxCount _n) mx+                    in ShaclModel.Definition {+                      ShaclModel.definitionIri = iri,+                      ShaclModel.definitionTarget = ShaclModel.PropertyShape {+                        ShaclModel.propertyShapeCommon = _cp,+                        ShaclModel.propertyShapeConstraints = (Sets.fromList (Optionals.cat [+                          minC,+                          maxC])),+                        ShaclModel.propertyShapeDefaultValue = Nothing,+                        ShaclModel.propertyShapeDescription = (Syntax.LangStrings Maps.empty),+                        ShaclModel.propertyShapeName = (Syntax.LangStrings Maps.empty),+                        ShaclModel.propertyShapeOrder = order,+                        ShaclModel.propertyShapePath = iri}}) (encodeType rname t cx)+      in (forType (Just 1) (Just 1) ftype)+-- | Encode a list of terms as RDF list structure+encodeList :: Syntax.Resource -> [Core.Term] -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Description], Int)+encodeList subj terms cx0 g =+    Logic.ifElse (Lists.null terms) (Right (+      [+        Syntax.Description {+          Syntax.descriptionSubject = (Syntax.NodeIri (Syntax.Iri "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil")),+          Syntax.descriptionGraph = (Syntax.Graph Sets.empty)}],+      cx0)) (Optionals.cases (Lists.uncons terms) (Right ([], cx0)) (\p ->+      let pair1 = Utils.nextBlankNode cx0+          node1 = Pairs.first pair1+          cx1 = Pairs.second pair1+      in (Eithers.bind (encodeTerm node1 (Pairs.first p) cx1 g) (\_r1 ->+        let fdescs = Pairs.first _r1+            cx2 = Pairs.second _r1+            firstTriples = Lists.concat2 (Utils.triplesOf fdescs) (Utils.forObjects subj (Utils.rdfIri "first") (Utils.subjectsOf fdescs))+            pair2 = Utils.nextBlankNode cx2+            next = Pairs.first pair2+            cx3 = Pairs.second pair2+        in (Eithers.map (\_r2 ->+          let rdescs = Pairs.first _r2+              cx4 = Pairs.second _r2+              restTriples = Lists.concat2 (Utils.triplesOf rdescs) (Utils.forObjects subj (Utils.rdfIri "rest") (Utils.subjectsOf rdescs))+          in (+            [+              Syntax.Description {+                Syntax.descriptionSubject = (Utils.resourceToNode subj),+                Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat2 firstTriples restTriples)))}],+            cx4)) (encodeList next (Pairs.second p) cx3 g))))))+-- | Encode a LiteralType as SHACL CommonProperties with an XSD datatype constraint+encodeLiteralType :: Core.LiteralType -> ShaclModel.CommonProperties+encodeLiteralType lt =++      let xsd = \local -> common [+            ShaclModel.CommonConstraintDatatype (Utils.xmlSchemaDatatypeIri local)]+      in case lt of+        Core.LiteralTypeBinary -> xsd "base64Binary"+        Core.LiteralTypeBoolean -> xsd "boolean"+        Core.LiteralTypeFloat v0 -> case v0 of+          Core.FloatTypeFloat32 -> xsd "float"+          Core.FloatTypeFloat64 -> xsd "double"+        Core.LiteralTypeInteger v0 -> case v0 of+          Core.IntegerTypeBigint -> xsd "integer"+          Core.IntegerTypeInt8 -> xsd "byte"+          Core.IntegerTypeInt16 -> xsd "short"+          Core.IntegerTypeInt32 -> xsd "int"+          Core.IntegerTypeInt64 -> xsd "long"+          Core.IntegerTypeUint8 -> xsd "unsignedByte"+          Core.IntegerTypeUint16 -> xsd "unsignedShort"+          Core.IntegerTypeUint32 -> xsd "unsignedInt"+          Core.IntegerTypeUint64 -> xsd "unsignedLong"+        Core.LiteralTypeString -> xsd "string"+-- | Encode a Hydra term as a list of RDF Descriptions+encodeTerm :: Syntax.Resource -> Core.Term -> Int -> Graph.Graph -> Either Errors.Error ([Syntax.Description], Int)+encodeTerm subject term cx g =+    case term of+      Core.TermAnnotated v0 -> encodeTerm subject (Core.annotatedTermBody v0) cx g+      Core.TermList v0 -> encodeList subject v0 cx g+      Core.TermLiteral v0 -> Right (+        [+          Syntax.Description {+            Syntax.descriptionSubject = (Syntax.NodeLiteral (Utils.encodeLiteral v0)),+            Syntax.descriptionGraph = (Syntax.Graph Sets.empty)}],+        cx)+      Core.TermMap v0 -> Eithers.map (\_r -> (+        [+          Syntax.Description {+            Syntax.descriptionSubject = (Utils.resourceToNode subject),+            Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat (Pairs.first _r))))}],+        (Pairs.second _r))) (foldAccumResult (\_cx0 -> \kv -> Eithers.bind (ExtractCore.string g (Strip.deannotateTerm (Pairs.first kv))) (\_ks ->+        let pair2 = Utils.nextBlankNode _cx0+            node2 = Pairs.first pair2+            cx2 = Pairs.second pair2+        in (Eithers.map (\_dr -> (+          Lists.concat2 (Utils.forObjects subject (Utils.keyIri _ks) (Utils.subjectsOf (Pairs.first _dr))) (Utils.triplesOf (Pairs.first _dr)),+          (Pairs.second _dr))) (encodeTerm node2 (Pairs.second kv) cx2 g)))) cx (Maps.toList v0))+      Core.TermWrap v0 -> Eithers.map (\_dr ->+        let descs = Pairs.first _dr+            cx1 = Pairs.second _dr+        in (+          Optionals.fromOptional descs (Optionals.map (\p -> Lists.cons (withType (Core.wrappedTermTypeName v0) (Pairs.first p)) (Pairs.second p)) (Lists.uncons descs)),+          cx1)) (encodeTerm subject (Core.wrappedTermBody v0) cx g)+      Core.TermOptional v0 -> Optionals.cases v0 (Right ([], cx)) (\_inner -> encodeTerm subject _inner cx g)+      Core.TermRecord v0 ->+        let rname = Core.recordTypeName v0+            fields = Core.recordFields v0+        in (Eithers.map (\_r -> (+          [+            withType rname (Syntax.Description {+              Syntax.descriptionSubject = (Utils.resourceToNode subject),+              Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Lists.concat (Pairs.first _r))))})],+          (Pairs.second _r))) (foldAccumResult (\_cx0 -> \field -> encodeField rname subject field _cx0 g) cx fields))+      Core.TermSet v0 -> Eithers.map (\_r -> (Lists.concat (Pairs.first _r), (Pairs.second _r))) (foldAccumResult (\_cx0 -> \t ->+        let pair3 = Utils.nextBlankNode _cx0+            node3 = Pairs.first pair3+            cx3 = Pairs.second pair3+        in (encodeTerm node3 t cx3 g)) cx (Sets.toList v0))+      Core.TermInject v0 ->+        let rname = Core.injectionTypeName v0+            field = Core.injectionField v0+        in (Eithers.map (\_r -> (+          [+            withType rname (Syntax.Description {+              Syntax.descriptionSubject = (Utils.resourceToNode subject),+              Syntax.descriptionGraph = (Syntax.Graph (Sets.fromList (Pairs.first _r)))})],+          (Pairs.second _r))) (encodeField rname subject field cx g))+      _ -> unexpectedE "RDF-compatible term" "unsupported term variant"+-- | Encode a Hydra type as SHACL CommonProperties+encodeType :: Core.Name -> Core.Type -> t0 -> Either Errors.Error ShaclModel.CommonProperties+encodeType tname typ cx =++      let any = Right (common [])+      in case (Strip.deannotateType typ) of+        Core.TypeEither _ -> any+        Core.TypeList _ -> any+        Core.TypeLiteral v0 -> Right (encodeLiteralType v0)+        Core.TypeMap _ -> any+        Core.TypePair _ -> any+        Core.TypeWrap _ -> any+        Core.TypeRecord v0 -> Eithers.map (\_props -> common [+          ShaclModel.CommonConstraintProperty (Sets.fromList (Lists.map (\_p -> ShaclModel.ReferenceDefinition _p) _props))]) (Eithers.mapList (\_pair -> encodeFieldType tname (Just (Pairs.first _pair)) (Pairs.second _pair) cx) (Lists.zip (Lists.map (\_i -> Literals.int32ToBigint _i) (Math.range 0 (Lists.length v0))) v0))+        Core.TypeSet _ -> any+        Core.TypeUnion v0 -> Eithers.map (\_props -> common [+          ShaclModel.CommonConstraintXone (Sets.fromList (Lists.map (\_p -> ShaclModel.ReferenceAnonymous (node [+            ShaclModel.CommonConstraintProperty (Sets.fromList [+              ShaclModel.ReferenceDefinition _p])])) _props))]) (Eithers.mapList (\_ft -> encodeFieldType tname Nothing _ft cx) v0)+        Core.TypeUnit -> any+        Core.TypeVariable v0 -> Right (common [+          ShaclModel.CommonConstraintNode (Sets.fromList [+            ShaclModel.ReferenceNamed (Utils.nameToIri v0)])])+        _ -> unexpectedE "type" "unsupported type variant"+-- | Construct an error result with the given message+err :: String -> Either Errors.Error t0+err msg = Left (Errors.ErrorOther (Errors.OtherError msg))+-- | Fold over a list, accumulating results and threading context through each step+foldAccumResult :: (t0 -> t1 -> Either t2 (t3, t0)) -> t0 -> [t1] -> Either t2 ([t3], t0)+foldAccumResult f cx xs =+    Optionals.cases (Lists.uncons xs) (Right ([], cx)) (\p -> Eithers.bind (f cx (Pairs.first p)) (\_r -> Eithers.map (\_rest -> (Lists.cons (Pairs.first _r) (Pairs.first _rest), (Pairs.second _rest))) (foldAccumResult f (Pairs.second _r) (Pairs.second p))))+-- | Construct a SHACL node shape from a list of common constraints+node :: [ShaclModel.CommonConstraint] -> ShaclModel.Shape+node constraints = ShaclModel.ShapeNode (ShaclModel.NodeShape {+  ShaclModel.nodeShapeCommon = (common constraints)})+-- | Construct a default property shape with the given IRI as its path+property :: Syntax.Iri -> ShaclModel.PropertyShape+property iri =+    ShaclModel.PropertyShape {+      ShaclModel.propertyShapeCommon = defaultCommonProperties,+      ShaclModel.propertyShapeConstraints = Sets.empty,+      ShaclModel.propertyShapeDefaultValue = Nothing,+      ShaclModel.propertyShapeDescription = (Syntax.LangStrings Maps.empty),+      ShaclModel.propertyShapeName = (Syntax.LangStrings Maps.empty),+      ShaclModel.propertyShapeOrder = Nothing,+      ShaclModel.propertyShapePath = iri}+-- | Encode a module's type elements as a SHACL ShapesGraph+shaclCoder :: Packaging.Module -> t0 -> Graph.Graph -> Either Errors.Error (ShaclModel.ShapesGraph, t0)+shaclCoder mod cx g =++      let typeEls =+              Optionals.cat (Lists.map (\d -> case d of+                Packaging.DefinitionType v0 -> Just ((\name -> \typ ->+                  let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type")+                      dataTerm =+                              Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm {+                                Core.annotatedTermBody = (EncodeCore.type_ typ),+                                Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [+                                  (Constants.keyType, schemaTerm)]))}))+                  in Core.Binding {+                    Core.bindingName = name,+                    Core.bindingTerm = dataTerm,+                    Core.bindingTypeScheme = (Just (Core.TypeScheme {+                      Core.typeSchemeVariables = [],+                      Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                      Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0)))+                _ -> Nothing) (Packaging.moduleDefinitions mod))+          toShape =+                  \el -> Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_t -> _t) (DecodeCore.type_ g (Core.bindingTerm el))) (\_typ -> Eithers.map (\_cp -> ShaclModel.Definition {+                    ShaclModel.definitionIri = (elementIri el),+                    ShaclModel.definitionTarget = (ShaclModel.ShapeNode (ShaclModel.NodeShape {+                      ShaclModel.nodeShapeCommon = _cp}))}) (encodeType (Core.bindingName el) _typ cx))+      in (Eithers.map (\_shapes -> (ShaclModel.ShapesGraph (Sets.fromList _shapes), cx)) (Eithers.mapList toShape typeEls))+-- | Construct an error for unexpected input, given expected and found descriptions+unexpectedE :: String -> String -> Either Errors.Error t0+unexpectedE expected found =+    err (Strings.cat [+      "Expected ",+      expected,+      ", found: ",+      found])+-- | Add an rdf:type triple to an RDF Description+withType :: Core.Name -> Syntax.Description -> Syntax.Description+withType name desc =++      let subj = Syntax.descriptionSubject desc+          triples = Syntax.unGraph (Syntax.descriptionGraph desc)+          subjRes =+                  case subj of+                    Syntax.NodeIri v0 -> Syntax.ResourceIri v0+                    Syntax.NodeBnode v0 -> Syntax.ResourceBnode v0+          triple =+                  Syntax.Triple {+                    Syntax.tripleSubject = subjRes,+                    Syntax.triplePredicate = (Utils.rdfIri "type"),+                    Syntax.tripleObject = (Syntax.NodeIri (Utils.nameToIri name))}+      in Syntax.Description {+        Syntax.descriptionSubject = subj,+        Syntax.descriptionGraph = (Syntax.Graph (Sets.insert triple triples))}

@@ -0,0 +1,79 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Language constraints for W3C SHACL++module Hydra.Shacl.Language where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+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+-- | Language constraints for W3C SHACL+shaclLanguage :: Coders.Language+shaclLanguage =+    Coders.Language {+      Coders.languageName = (Coders.LanguageName "hydra.shacl"),+      Coders.languageConstraints = Coders.LanguageConstraints {+        Coders.languageConstraintsLiteralVariants = literalVariants,+        Coders.languageConstraintsFloatTypes = floatTypes,+        Coders.languageConstraintsIntegerTypes = integerTypes,+        Coders.languageConstraintsTermVariants = termVariants,+        Coders.languageConstraintsTypeVariants = typeVariants,+        Coders.languageConstraintsTypes = typePredicate}}+  where+    literalVariants =+        Sets.fromList [+          Variants.LiteralVariantBoolean,+          Variants.LiteralVariantFloat,+          Variants.LiteralVariantInteger,+          Variants.LiteralVariantString]+    floatTypes =+        Sets.fromList [+          Core.FloatTypeFloat32,+          Core.FloatTypeFloat64]+    integerTypes =+        Sets.fromList [+          Core.IntegerTypeInt32,+          Core.IntegerTypeInt64]+    termVariants =+        Sets.fromList [+          Variants.TermVariantList,+          Variants.TermVariantLiteral,+          Variants.TermVariantMap,+          Variants.TermVariantWrap,+          Variants.TermVariantOptional,+          Variants.TermVariantRecord,+          Variants.TermVariantSet,+          Variants.TermVariantInject]+    typeVariants =+        Sets.fromList [+          Variants.TypeVariantAnnotated,+          Variants.TypeVariantList,+          Variants.TypeVariantLiteral,+          Variants.TypeVariantMap,+          Variants.TypeVariantWrap,+          Variants.TypeVariantOptional,+          Variants.TypeVariantRecord,+          Variants.TypeVariantSet,+          Variants.TypeVariantUnion]+    typePredicate = \_ -> True

@@ -0,0 +1,260 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A SHACL syntax model. See https://www.w3.org/TR/shacl++module Hydra.Shacl.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Rdf.Syntax as Syntax+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | See https://www.w3.org/TR/shacl/#ClosedPatterConstraintComponent+data Closed =+  Closed {+    closedIsClosed :: Bool,+    closedIgnoredProperties :: (Maybe (S.Set Syntax.Property))}+  deriving (Eq, Ord, Read, Show)+_Closed = Core.Name "hydra.shacl.model.Closed"+_Closed_isClosed = Core.Name "isClosed"+_Closed_ignoredProperties = Core.Name "ignoredProperties"+-- | Any of a number of constraint parameters which can be applied either to node or property shapes+data CommonConstraint =+  -- | See https://www.w3.org/TR/shacl/#AndConstraintComponent+  CommonConstraintAnd (S.Set (Reference Shape)) |+  -- | See https://www.w3.org/TR/shacl/#ClosedConstraintComponent+  CommonConstraintClosed Closed |+  -- | See https://www.w3.org/TR/shacl/#ClassConstraintComponent+  CommonConstraintClass (S.Set Syntax.RdfsClass) |+  -- | See https://www.w3.org/TR/shacl/#DatatypeConstraintComponent+  CommonConstraintDatatype Syntax.Iri |+  -- | See https://www.w3.org/TR/shacl/#DisjointConstraintComponent+  CommonConstraintDisjoint (S.Set Syntax.Property) |+  -- | See https://www.w3.org/TR/shacl/#EqualsConstraintComponent+  CommonConstraintEquals (S.Set Syntax.Property) |+  -- | Specifies the condition that at least one value node is equal to the given RDF term. See https://www.w3.org/TR/shacl/#HasValueConstraintComponent+  CommonConstraintHasValue (S.Set Syntax.Node) |+  -- | Specifies the condition that each value node is a member of a provided SHACL list. See https://www.w3.org/TR/shacl/#InConstraintComponent+  CommonConstraintIn [Syntax.Node] |+  -- | See https://www.w3.org/TR/shacl/#LanguageInConstraintComponent+  CommonConstraintLanguageIn (S.Set Syntax.LanguageTag) |+  -- | See https://www.w3.org/TR/shacl/#NodeKindConstraintComponent+  CommonConstraintNodeKind NodeKind |+  -- | See https://www.w3.org/TR/shacl/#NodeConstraintComponent+  CommonConstraintNode (S.Set (Reference NodeShape)) |+  -- | See https://www.w3.org/TR/shacl/#NotConstraintComponent+  CommonConstraintNot (S.Set (Reference Shape)) |+  -- | See https://www.w3.org/TR/shacl/#MaxExclusiveConstraintComponent+  CommonConstraintMaxExclusive Syntax.Literal |+  -- | See https://www.w3.org/TR/shacl/#MaxInclusiveConstraintComponent+  CommonConstraintMaxInclusive Syntax.Literal |+  -- | See https://www.w3.org/TR/shacl/#MaxLengthConstraintComponent+  CommonConstraintMaxLength Integer |+  -- | See https://www.w3.org/TR/shacl/#MinExclusiveConstraintComponent+  CommonConstraintMinExclusive Syntax.Literal |+  -- | See https://www.w3.org/TR/shacl/#MinInclusiveConstraintComponent+  CommonConstraintMinInclusive Syntax.Literal |+  -- | See https://www.w3.org/TR/shacl/#MinLengthConstraintComponent+  CommonConstraintMinLength Integer |+  -- | See https://www.w3.org/TR/shacl/#PatternConstraintComponent+  CommonConstraintPattern Pattern |+  -- | See https://www.w3.org/TR/shacl/#PropertyConstraintComponent+  CommonConstraintProperty (S.Set (Reference PropertyShape)) |+  -- | See https://www.w3.org/TR/shacl/#OrConstraintComponent+  CommonConstraintOr (S.Set (Reference Shape)) |+  -- | See https://www.w3.org/TR/shacl/#XoneConstraintComponent+  CommonConstraintXone (S.Set (Reference Shape))+  deriving (Eq, Ord, Read, Show)+_CommonConstraint = Core.Name "hydra.shacl.model.CommonConstraint"+_CommonConstraint_and = Core.Name "and"+_CommonConstraint_closed = Core.Name "closed"+_CommonConstraint_class = Core.Name "class"+_CommonConstraint_datatype = Core.Name "datatype"+_CommonConstraint_disjoint = Core.Name "disjoint"+_CommonConstraint_equals = Core.Name "equals"+_CommonConstraint_hasValue = Core.Name "hasValue"+_CommonConstraint_in = Core.Name "in"+_CommonConstraint_languageIn = Core.Name "languageIn"+_CommonConstraint_nodeKind = Core.Name "nodeKind"+_CommonConstraint_node = Core.Name "node"+_CommonConstraint_not = Core.Name "not"+_CommonConstraint_maxExclusive = Core.Name "maxExclusive"+_CommonConstraint_maxInclusive = Core.Name "maxInclusive"+_CommonConstraint_maxLength = Core.Name "maxLength"+_CommonConstraint_minExclusive = Core.Name "minExclusive"+_CommonConstraint_minInclusive = Core.Name "minInclusive"+_CommonConstraint_minLength = Core.Name "minLength"+_CommonConstraint_pattern = Core.Name "pattern"+_CommonConstraint_property = Core.Name "property"+_CommonConstraint_or = Core.Name "or"+_CommonConstraint_xone = Core.Name "xone"+-- | Common constraint parameters and other properties for SHACL shapes+data CommonProperties =+  CommonProperties {+    -- | Common constraint parameters attached to this shape+    commonPropertiesConstraints :: (S.Set CommonConstraint),+    -- | See https://www.w3.org/TR/shacl/#deactivated+    commonPropertiesDeactivated :: (Maybe Bool),+    -- | See https://www.w3.org/TR/shacl/#message+    commonPropertiesMessage :: Syntax.LangStrings,+    -- | See https://www.w3.org/TR/shacl/#severity+    commonPropertiesSeverity :: Severity,+    -- | See https://www.w3.org/TR/shacl/#targetClass+    commonPropertiesTargetClass :: (S.Set Syntax.RdfsClass),+    -- | See https://www.w3.org/TR/shacl/#targetNode+    commonPropertiesTargetNode :: (S.Set Syntax.IriOrLiteral),+    -- | See https://www.w3.org/TR/shacl/#targetObjectsOf+    commonPropertiesTargetObjectsOf :: (S.Set Syntax.Property),+    -- | See https://www.w3.org/TR/shacl/#targetSubjectsOf+    commonPropertiesTargetSubjectsOf :: (S.Set Syntax.Property)}+  deriving (Eq, Ord, Read, Show)+_CommonProperties = Core.Name "hydra.shacl.model.CommonProperties"+_CommonProperties_constraints = Core.Name "constraints"+_CommonProperties_deactivated = Core.Name "deactivated"+_CommonProperties_message = Core.Name "message"+_CommonProperties_severity = Core.Name "severity"+_CommonProperties_targetClass = Core.Name "targetClass"+_CommonProperties_targetNode = Core.Name "targetNode"+_CommonProperties_targetObjectsOf = Core.Name "targetObjectsOf"+_CommonProperties_targetSubjectsOf = Core.Name "targetSubjectsOf"+-- | An instance of a type like sh:Shape or sh:NodeShape, together with a unique IRI for that instance+data Definition a =+  Definition {+    definitionIri :: Syntax.Iri,+    definitionTarget :: a}+  deriving (Eq, Ord, Read, Show)+_Definition = Core.Name "hydra.shacl.model.Definition"+_Definition_iri = Core.Name "iri"+_Definition_target = Core.Name "target"+data NodeKind =+  -- | A blank node+  NodeKindBlankNode |+  -- | An IRI+  NodeKindIri |+  -- | A literal+  NodeKindLiteral |+  -- | A blank node or an IRI+  NodeKindBlankNodeOrIri |+  -- | A blank node or a literal+  NodeKindBlankNodeOrLiteral |+  -- | An IRI or a literal+  NodeKindIriOrLiteral+  deriving (Eq, Ord, Read, Show)+_NodeKind = Core.Name "hydra.shacl.model.NodeKind"+_NodeKind_blankNode = Core.Name "blankNode"+_NodeKind_iri = Core.Name "iri"+_NodeKind_literal = Core.Name "literal"+_NodeKind_blankNodeOrIri = Core.Name "blankNodeOrIri"+_NodeKind_blankNodeOrLiteral = Core.Name "blankNodeOrLiteral"+_NodeKind_iriOrLiteral = Core.Name "iriOrLiteral"+-- | A SHACL node shape. See https://www.w3.org/TR/shacl/#node-shapes+data NodeShape =+  NodeShape {+    nodeShapeCommon :: CommonProperties}+  deriving (Eq, Ord, Read, Show)+_NodeShape = Core.Name "hydra.shacl.model.NodeShape"+_NodeShape_common = Core.Name "common"+-- | A SHACL pattern. See https://www.w3.org/TR/shacl/#PatternConstraintComponent+data Pattern =+  Pattern {+    patternRegex :: String,+    patternFlags :: (Maybe String)}+  deriving (Eq, Ord, Read, Show)+_Pattern = Core.Name "hydra.shacl.model.Pattern"+_Pattern_regex = Core.Name "regex"+_Pattern_flags = Core.Name "flags"+-- | A SHACL property shape. See https://www.w3.org/TR/shacl/#property-shapes+data PropertyShape =+  PropertyShape {+    propertyShapeCommon :: CommonProperties,+    -- | Any property shape -specific constraint parameters+    propertyShapeConstraints :: (S.Set PropertyShapeConstraint),+    -- | See https://www.w3.org/TR/shacl/#defaultValue+    propertyShapeDefaultValue :: (Maybe Syntax.Node),+    -- | See https://www.w3.org/TR/shacl/#name+    propertyShapeDescription :: Syntax.LangStrings,+    -- | See https://www.w3.org/TR/shacl/#name+    propertyShapeName :: Syntax.LangStrings,+    -- | See https://www.w3.org/TR/shacl/#order+    propertyShapeOrder :: (Maybe Integer),+    propertyShapePath :: Syntax.Iri}+  deriving (Eq, Ord, Read, Show)+_PropertyShape = Core.Name "hydra.shacl.model.PropertyShape"+_PropertyShape_common = Core.Name "common"+_PropertyShape_constraints = Core.Name "constraints"+_PropertyShape_defaultValue = Core.Name "defaultValue"+_PropertyShape_description = Core.Name "description"+_PropertyShape_name = Core.Name "name"+_PropertyShape_order = Core.Name "order"+_PropertyShape_path = Core.Name "path"+-- | A number of constraint parameters which are specific to property shapes, and cannot be applied to node shapes+data PropertyShapeConstraint =+  -- | See https://www.w3.org/TR/shacl/#LessThanConstraintComponent+  PropertyShapeConstraintLessThan (S.Set Syntax.Property) |+  -- | See https://www.w3.org/TR/shacl/#LessThanOrEqualsConstraintComponent+  PropertyShapeConstraintLessThanOrEquals (S.Set Syntax.Property) |+  -- | The maximum cardinality. Node shapes cannot have any value for sh:maxCount. See https://www.w3.org/TR/shacl/#MaxCountConstraintComponent+  PropertyShapeConstraintMaxCount Integer |+  -- | The minimum cardinality. Node shapes cannot have any value for sh:minCount. See https://www.w3.org/TR/shacl/#MinCountConstraintComponent+  PropertyShapeConstraintMinCount Integer |+  -- | See https://www.w3.org/TR/shacl/#UniqueLangConstraintComponent+  PropertyShapeConstraintUniqueLang Bool |+  -- | See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent+  PropertyShapeConstraintQualifiedValueShape QualifiedValueShape+  deriving (Eq, Ord, Read, Show)+_PropertyShapeConstraint = Core.Name "hydra.shacl.model.PropertyShapeConstraint"+_PropertyShapeConstraint_lessThan = Core.Name "lessThan"+_PropertyShapeConstraint_lessThanOrEquals = Core.Name "lessThanOrEquals"+_PropertyShapeConstraint_maxCount = Core.Name "maxCount"+_PropertyShapeConstraint_minCount = Core.Name "minCount"+_PropertyShapeConstraint_uniqueLang = Core.Name "uniqueLang"+_PropertyShapeConstraint_qualifiedValueShape = Core.Name "qualifiedValueShape"+-- | See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent+data QualifiedValueShape =+  QualifiedValueShape {+    qualifiedValueShapeQualifiedValueShape :: (Reference Shape),+    qualifiedValueShapeQualifiedMaxCount :: Integer,+    qualifiedValueShapeQualifiedMinCount :: Integer,+    qualifiedValueShapeQualifiedValueShapesDisjoint :: (Maybe Bool)}+  deriving (Eq, Ord, Read, Show)+_QualifiedValueShape = Core.Name "hydra.shacl.model.QualifiedValueShape"+_QualifiedValueShape_qualifiedValueShape = Core.Name "qualifiedValueShape"+_QualifiedValueShape_qualifiedMaxCount = Core.Name "qualifiedMaxCount"+_QualifiedValueShape_qualifiedMinCount = Core.Name "qualifiedMinCount"+_QualifiedValueShape_qualifiedValueShapesDisjoint = Core.Name "qualifiedValueShapesDisjoint"+-- | Either an instance of a type like sh:Shape or sh:NodeShape, or an IRI which refers to an instance of that type+data Reference a =+  ReferenceNamed Syntax.Iri |+  -- | An anonymous instance+  ReferenceAnonymous a |+  -- | An inline definition+  ReferenceDefinition (Definition a)+  deriving (Eq, Ord, Read, Show)+_Reference = Core.Name "hydra.shacl.model.Reference"+_Reference_named = Core.Name "named"+_Reference_anonymous = Core.Name "anonymous"+_Reference_definition = Core.Name "definition"+data Severity =+  -- | A non-critical constraint violation indicating an informative message+  SeverityInfo |+  -- | A non-critical constraint violation indicating a warning+  SeverityWarning |+  -- | A constraint violation+  SeverityViolation+  deriving (Eq, Ord, Read, Show)+_Severity = Core.Name "hydra.shacl.model.Severity"+_Severity_info = Core.Name "info"+_Severity_warning = Core.Name "warning"+_Severity_violation = Core.Name "violation"+-- | A SHACL node or property shape. See https://www.w3.org/TR/shacl/#shapes+data Shape =+  ShapeNode NodeShape |+  ShapeProperty PropertyShape+  deriving (Eq, Ord, Read, Show)+_Shape = Core.Name "hydra.shacl.model.Shape"+_Shape_node = Core.Name "node"+_Shape_property = Core.Name "property"+-- | An RDF graph containing zero or more shapes that is passed into a SHACL validation process so that a data graph can be validated against the shapes+newtype ShapesGraph =+  ShapesGraph {+    unShapesGraph :: (S.Set (Definition Shape))}+  deriving (Eq, Ord, Read, Show)+_ShapesGraph = Core.Name "hydra.shacl.model.ShapesGraph"

@@ -0,0 +1,1068 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A Shex model. Based on the BNF at:+-- |   https://github.com/shexSpec/grammar/blob/master/bnf++module Hydra.Shex.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 ShexDoc =+  ShexDoc {+    shexDocListOfDirective :: [Directive],+    shexDocSequence :: (Maybe ShexDoc_Sequence_Option),+    shexDocPrefixDecl :: PrefixDecl}+  deriving (Eq, Ord, Read, Show)+_ShexDoc = Core.Name "hydra.shex.syntax.ShexDoc"+_ShexDoc_listOfDirective = Core.Name "listOfDirective"+_ShexDoc_Sequence = Core.Name "Sequence"+_ShexDoc_PrefixDecl = Core.Name "PrefixDecl"+data ShexDoc_Sequence_Option =+  ShexDoc_Sequence_Option {+    shexDoc_Sequence_OptionAlts :: ShexDoc_Sequence_Option_Alts,+    shexDoc_Sequence_OptionListOfStatement :: [Statement]}+  deriving (Eq, Ord, Read, Show)+_ShexDoc_Sequence_Option = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option"+_ShexDoc_Sequence_Option_alts = Core.Name "alts"+_ShexDoc_Sequence_Option_listOfStatement = Core.Name "listOfStatement"+data ShexDoc_Sequence_Option_Alts =+  ShexDoc_Sequence_Option_AltsNotStartAction NotStartAction |+  ShexDoc_Sequence_Option_AltsStartActions StartActions+  deriving (Eq, Ord, Read, Show)+_ShexDoc_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option_Alts"+_ShexDoc_Sequence_Option_Alts_NotStartAction = Core.Name "NotStartAction"+_ShexDoc_Sequence_Option_Alts_StartActions = Core.Name "StartActions"+data Directive =+  DirectiveBaseDecl BaseDecl |+  DirectivePrefixDecl PrefixDecl+  deriving (Eq, Ord, Read, Show)+_Directive = Core.Name "hydra.shex.syntax.Directive"+_Directive_BaseDecl = Core.Name "BaseDecl"+_Directive_PrefixDecl = Core.Name "PrefixDecl"+newtype BaseDecl =+  BaseDecl {+    unBaseDecl :: IriRef}+  deriving (Eq, Ord, Read, Show)+_BaseDecl = Core.Name "hydra.shex.syntax.BaseDecl"+data PrefixDecl =+  PrefixDecl {+    prefixDeclPnameNs :: PnameNs,+    prefixDeclIriRef :: IriRef}+  deriving (Eq, Ord, Read, Show)+_PrefixDecl = Core.Name "hydra.shex.syntax.PrefixDecl"+_PrefixDecl_PnameNs = Core.Name "PnameNs"+_PrefixDecl_IriRef = Core.Name "IriRef"+data NotStartAction =+  NotStartActionStart ShapeExpression |+  NotStartActionShapeExprDecl NotStartAction_ShapeExprDecl+  deriving (Eq, Ord, Read, Show)+_NotStartAction = Core.Name "hydra.shex.syntax.NotStartAction"+_NotStartAction_start = Core.Name "start"+_NotStartAction_shapeExprDecl = Core.Name "shapeExprDecl"+data NotStartAction_ShapeExprDecl =+  NotStartAction_ShapeExprDecl {+    notStartAction_ShapeExprDeclShapeExprLabel :: ShapeExprLabel,+    notStartAction_ShapeExprDeclAlts :: NotStartAction_ShapeExprDecl_Alts}+  deriving (Eq, Ord, Read, Show)+_NotStartAction_ShapeExprDecl = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl"+_NotStartAction_ShapeExprDecl_ShapeExprLabel = Core.Name "ShapeExprLabel"+_NotStartAction_ShapeExprDecl_alts = Core.Name "alts"+data NotStartAction_ShapeExprDecl_Alts =+  NotStartAction_ShapeExprDecl_AltsShapeExpression ShapeExpression |+  NotStartAction_ShapeExprDecl_AltsEXTERNAL+  deriving (Eq, Ord, Read, Show)+_NotStartAction_ShapeExprDecl_Alts = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl_Alts"+_NotStartAction_ShapeExprDecl_Alts_ShapeExpression = Core.Name "ShapeExpression"+_NotStartAction_ShapeExprDecl_Alts_EXTERNAL = Core.Name "EXTERNAL"+newtype StartActions =+  StartActions {+    unStartActions :: [CodeDecl]}+  deriving (Eq, Ord, Read, Show)+_StartActions = Core.Name "hydra.shex.syntax.StartActions"+data Statement =+  StatementDirective Directive |+  StatementNotStartAction NotStartAction+  deriving (Eq, Ord, Read, Show)+_Statement = Core.Name "hydra.shex.syntax.Statement"+_Statement_Directive = Core.Name "Directive"+_Statement_NotStartAction = Core.Name "NotStartAction"+newtype ShapeExpression =+  ShapeExpression {+    unShapeExpression :: ShapeOr}+  deriving (Eq, Ord, Read, Show)+_ShapeExpression = Core.Name "hydra.shex.syntax.ShapeExpression"+newtype InlineShapeExpression =+  InlineShapeExpression {+    unInlineShapeExpression :: InlineShapeOr}+  deriving (Eq, Ord, Read, Show)+_InlineShapeExpression = Core.Name "hydra.shex.syntax.InlineShapeExpression"+data ShapeOr =+  ShapeOr {+    shapeOrShapeAnd :: ShapeAnd,+    shapeOrListOfSequence :: [ShapeAnd]}+  deriving (Eq, Ord, Read, Show)+_ShapeOr = Core.Name "hydra.shex.syntax.ShapeOr"+_ShapeOr_ShapeAnd = Core.Name "ShapeAnd"+_ShapeOr_listOfSequence = Core.Name "listOfSequence"+data InlineShapeOr =+  InlineShapeOr {+    inlineShapeOrShapeAnd :: ShapeAnd,+    inlineShapeOrListOfSequence :: [InlineShapeAnd]}+  deriving (Eq, Ord, Read, Show)+_InlineShapeOr = Core.Name "hydra.shex.syntax.InlineShapeOr"+_InlineShapeOr_ShapeAnd = Core.Name "ShapeAnd"+_InlineShapeOr_listOfSequence = Core.Name "listOfSequence"+data ShapeAnd =+  ShapeAnd {+    shapeAndShapeNot :: ShapeNot,+    shapeAndListOfSequence :: [ShapeNot]}+  deriving (Eq, Ord, Read, Show)+_ShapeAnd = Core.Name "hydra.shex.syntax.ShapeAnd"+_ShapeAnd_ShapeNot = Core.Name "ShapeNot"+_ShapeAnd_listOfSequence = Core.Name "listOfSequence"+data InlineShapeAnd =+  InlineShapeAnd {+    inlineShapeAndInlineShapeNot :: InlineShapeNot,+    inlineShapeAndListOfSequence :: [InlineShapeNot]}+  deriving (Eq, Ord, Read, Show)+_InlineShapeAnd = Core.Name "hydra.shex.syntax.InlineShapeAnd"+_InlineShapeAnd_InlineShapeNot = Core.Name "InlineShapeNot"+_InlineShapeAnd_listOfSequence = Core.Name "listOfSequence"+data ShapeNot =+  ShapeNot {+    shapeNotNOT :: (Maybe ()),+    shapeNotShapeAtom :: ShapeAtom}+  deriving (Eq, Ord, Read, Show)+_ShapeNot = Core.Name "hydra.shex.syntax.ShapeNot"+_ShapeNot_NOT = Core.Name "NOT"+_ShapeNot_ShapeAtom = Core.Name "ShapeAtom"+data InlineShapeNot =+  InlineShapeNot {+    inlineShapeNotNOT :: (Maybe ()),+    inlineShapeNotInlineShapeAtom :: InlineShapeAtom}+  deriving (Eq, Ord, Read, Show)+_InlineShapeNot = Core.Name "hydra.shex.syntax.InlineShapeNot"+_InlineShapeNot_NOT = Core.Name "NOT"+_InlineShapeNot_InlineShapeAtom = Core.Name "InlineShapeAtom"+data ShapeAtom =+  ShapeAtomSequence ShapeAtom_Sequence |+  ShapeAtomShapeOrRef ShapeOrRef |+  ShapeAtomSequence2 ShapeExpression |+  ShapeAtomPeriod+  deriving (Eq, Ord, Read, Show)+_ShapeAtom = Core.Name "hydra.shex.syntax.ShapeAtom"+_ShapeAtom_sequence = Core.Name "sequence"+_ShapeAtom_ShapeOrRef = Core.Name "ShapeOrRef"+_ShapeAtom_sequence2 = Core.Name "sequence2"+_ShapeAtom_Period = Core.Name "Period"+data ShapeAtom_Sequence =+  ShapeAtom_Sequence {+    shapeAtom_SequenceNodeConstraint :: NodeConstraint,+    shapeAtom_SequenceShapeOrRef :: (Maybe ShapeOrRef)}+  deriving (Eq, Ord, Read, Show)+_ShapeAtom_Sequence = Core.Name "hydra.shex.syntax.ShapeAtom_Sequence"+_ShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"+_ShapeAtom_Sequence_ShapeOrRef = Core.Name "ShapeOrRef"+data InlineShapeAtom =+  InlineShapeAtomSequence InlineShapeAtom_Sequence |+  InlineShapeAtomSequence2 InlineShapeAtom_Sequence2 |+  InlineShapeAtomSequence3 ShapeExpression |+  InlineShapeAtomPeriod+  deriving (Eq, Ord, Read, Show)+_InlineShapeAtom = Core.Name "hydra.shex.syntax.InlineShapeAtom"+_InlineShapeAtom_sequence = Core.Name "sequence"+_InlineShapeAtom_sequence2 = Core.Name "sequence2"+_InlineShapeAtom_sequence3 = Core.Name "sequence3"+_InlineShapeAtom_Period = Core.Name "Period"+data InlineShapeAtom_Sequence =+  InlineShapeAtom_Sequence {+    inlineShapeAtom_SequenceNodeConstraint :: NodeConstraint,+    inlineShapeAtom_SequenceInlineShapeOrRef :: (Maybe InlineShapeOrRef)}+  deriving (Eq, Ord, Read, Show)+_InlineShapeAtom_Sequence = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence"+_InlineShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"+_InlineShapeAtom_Sequence_InlineShapeOrRef = Core.Name "InlineShapeOrRef"+data InlineShapeAtom_Sequence2 =+  InlineShapeAtom_Sequence2 {+    inlineShapeAtom_Sequence2InlineShapeOrRef :: InlineShapeOrRef,+    inlineShapeAtom_Sequence2NodeConstraint :: (Maybe NodeConstraint)}+  deriving (Eq, Ord, Read, Show)+_InlineShapeAtom_Sequence2 = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence2"+_InlineShapeAtom_Sequence2_InlineShapeOrRef = Core.Name "InlineShapeOrRef"+_InlineShapeAtom_Sequence2_NodeConstraint = Core.Name "NodeConstraint"+data ShapeOrRef =+  ShapeOrRefShapeDefinition ShapeDefinition |+  ShapeOrRefAtpNameLn AtpNameLn |+  ShapeOrRefAtpNameNs AtpNameNs |+  ShapeOrRefSequence ShapeExprLabel+  deriving (Eq, Ord, Read, Show)+_ShapeOrRef = Core.Name "hydra.shex.syntax.ShapeOrRef"+_ShapeOrRef_ShapeDefinition = Core.Name "ShapeDefinition"+_ShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"+_ShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"+_ShapeOrRef_sequence = Core.Name "sequence"+data InlineShapeOrRef =+  InlineShapeOrRefInlineShapeDefinition InlineShapeDefinition |+  InlineShapeOrRefAtpNameLn AtpNameLn |+  InlineShapeOrRefAtpNameNs AtpNameNs |+  InlineShapeOrRefSequence ShapeExprLabel+  deriving (Eq, Ord, Read, Show)+_InlineShapeOrRef = Core.Name "hydra.shex.syntax.InlineShapeOrRef"+_InlineShapeOrRef_InlineShapeDefinition = Core.Name "InlineShapeDefinition"+_InlineShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"+_InlineShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"+_InlineShapeOrRef_sequence = Core.Name "sequence"+data NodeConstraint =+  NodeConstraintSequence [XsFacet] |+  NodeConstraintSequence2 NodeConstraint_Sequence2 |+  NodeConstraintSequence3 NodeConstraint_Sequence3 |+  NodeConstraintSequence4 NodeConstraint_Sequence4 |+  NodeConstraintSequence5 NodeConstraint_Sequence5 |+  NodeConstraintListOfXsFacet [XsFacet]+  deriving (Eq, Ord, Read, Show)+_NodeConstraint = Core.Name "hydra.shex.syntax.NodeConstraint"+_NodeConstraint_sequence = Core.Name "sequence"+_NodeConstraint_sequence2 = Core.Name "sequence2"+_NodeConstraint_sequence3 = Core.Name "sequence3"+_NodeConstraint_sequence4 = Core.Name "sequence4"+_NodeConstraint_sequence5 = Core.Name "sequence5"+_NodeConstraint_listOfXsFacet = Core.Name "listOfXsFacet"+data NodeConstraint_Sequence2 =+  NodeConstraint_Sequence2 {+    nodeConstraint_Sequence2NonLiteralKind :: NonLiteralKind,+    nodeConstraint_Sequence2ListOfStringFacet :: [StringFacet]}+  deriving (Eq, Ord, Read, Show)+_NodeConstraint_Sequence2 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence2"+_NodeConstraint_Sequence2_NonLiteralKind = Core.Name "NonLiteralKind"+_NodeConstraint_Sequence2_listOfStringFacet = Core.Name "listOfStringFacet"+data NodeConstraint_Sequence3 =+  NodeConstraint_Sequence3 {+    nodeConstraint_Sequence3Datatype :: Datatype,+    nodeConstraint_Sequence3ListOfXsFacet :: [XsFacet]}+  deriving (Eq, Ord, Read, Show)+_NodeConstraint_Sequence3 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence3"+_NodeConstraint_Sequence3_Datatype = Core.Name "Datatype"+_NodeConstraint_Sequence3_listOfXsFacet = Core.Name "listOfXsFacet"+data NodeConstraint_Sequence4 =+  NodeConstraint_Sequence4 {+    nodeConstraint_Sequence4ValueSet :: ValueSet,+    nodeConstraint_Sequence4ListOfXsFacet :: [XsFacet]}+  deriving (Eq, Ord, Read, Show)+_NodeConstraint_Sequence4 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence4"+_NodeConstraint_Sequence4_ValueSet = Core.Name "ValueSet"+_NodeConstraint_Sequence4_listOfXsFacet = Core.Name "listOfXsFacet"+data NodeConstraint_Sequence5 =+  NodeConstraint_Sequence5 {+    nodeConstraint_Sequence5ValueSet :: ValueSet,+    nodeConstraint_Sequence5ListOfXsFacet :: [XsFacet]}+  deriving (Eq, Ord, Read, Show)+_NodeConstraint_Sequence5 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence5"+_NodeConstraint_Sequence5_ValueSet = Core.Name "ValueSet"+_NodeConstraint_Sequence5_listOfXsFacet = Core.Name "listOfXsFacet"+data NonLiteralKind =+  NonLiteralKindIRI |+  NonLiteralKindBNODE |+  NonLiteralKindNONLITERAL+  deriving (Eq, Ord, Read, Show)+_NonLiteralKind = Core.Name "hydra.shex.syntax.NonLiteralKind"+_NonLiteralKind_IRI = Core.Name "IRI"+_NonLiteralKind_BNODE = Core.Name "BNODE"+_NonLiteralKind_NONLITERAL = Core.Name "NONLITERAL"+data XsFacet =+  XsFacetStringFacet StringFacet |+  XsFacetNumericFacet NumericFacet+  deriving (Eq, Ord, Read, Show)+_XsFacet = Core.Name "hydra.shex.syntax.XsFacet"+_XsFacet_StringFacet = Core.Name "StringFacet"+_XsFacet_NumericFacet = Core.Name "NumericFacet"+data StringFacet =+  StringFacetSequence StringFacet_Sequence |+  StringFacetRegexp Regexp+  deriving (Eq, Ord, Read, Show)+_StringFacet = Core.Name "hydra.shex.syntax.StringFacet"+_StringFacet_sequence = Core.Name "sequence"+_StringFacet_Regexp = Core.Name "Regexp"+data StringFacet_Sequence =+  StringFacet_Sequence {+    stringFacet_SequenceStringLength :: StringLength,+    stringFacet_SequenceInteger :: Integer_}+  deriving (Eq, Ord, Read, Show)+_StringFacet_Sequence = Core.Name "hydra.shex.syntax.StringFacet_Sequence"+_StringFacet_Sequence_StringLength = Core.Name "StringLength"+_StringFacet_Sequence_Integer = Core.Name "Integer"+data StringLength =+  StringLengthLENGTH |+  StringLengthMINLENGTH |+  StringLengthMAXLENGTH+  deriving (Eq, Ord, Read, Show)+_StringLength = Core.Name "hydra.shex.syntax.StringLength"+_StringLength_LENGTH = Core.Name "LENGTH"+_StringLength_MINLENGTH = Core.Name "MINLENGTH"+_StringLength_MAXLENGTH = Core.Name "MAXLENGTH"+data NumericFacet =+  NumericFacetSequence NumericFacet_Sequence |+  NumericFacetSequence2 NumericFacet_Sequence2+  deriving (Eq, Ord, Read, Show)+_NumericFacet = Core.Name "hydra.shex.syntax.NumericFacet"+_NumericFacet_sequence = Core.Name "sequence"+_NumericFacet_sequence2 = Core.Name "sequence2"+data NumericFacet_Sequence =+  NumericFacet_Sequence {+    numericFacet_SequenceNumericRange :: NumericRange,+    numericFacet_SequenceNumericLiteral :: NumericLiteral}+  deriving (Eq, Ord, Read, Show)+_NumericFacet_Sequence = Core.Name "hydra.shex.syntax.NumericFacet_Sequence"+_NumericFacet_Sequence_NumericRange = Core.Name "NumericRange"+_NumericFacet_Sequence_NumericLiteral = Core.Name "NumericLiteral"+data NumericFacet_Sequence2 =+  NumericFacet_Sequence2 {+    numericFacet_Sequence2NumericLength :: NumericLength,+    numericFacet_Sequence2Integer :: Integer_}+  deriving (Eq, Ord, Read, Show)+_NumericFacet_Sequence2 = Core.Name "hydra.shex.syntax.NumericFacet_Sequence2"+_NumericFacet_Sequence2_NumericLength = Core.Name "NumericLength"+_NumericFacet_Sequence2_Integer = Core.Name "Integer"+data NumericRange =+  NumericRangeMININCLUSIVE |+  NumericRangeMINEXCLUSIVE |+  NumericRangeMAXINCLUSIVE |+  NumericRangeMAXEXCLUSIVE+  deriving (Eq, Ord, Read, Show)+_NumericRange = Core.Name "hydra.shex.syntax.NumericRange"+_NumericRange_MININCLUSIVE = Core.Name "MININCLUSIVE"+_NumericRange_MINEXCLUSIVE = Core.Name "MINEXCLUSIVE"+_NumericRange_MAXINCLUSIVE = Core.Name "MAXINCLUSIVE"+_NumericRange_MAXEXCLUSIVE = Core.Name "MAXEXCLUSIVE"+data NumericLength =+  NumericLengthTOTALDIGITS |+  NumericLengthFRACTIONDIGITS+  deriving (Eq, Ord, Read, Show)+_NumericLength = Core.Name "hydra.shex.syntax.NumericLength"+_NumericLength_TOTALDIGITS = Core.Name "TOTALDIGITS"+_NumericLength_FRACTIONDIGITS = Core.Name "FRACTIONDIGITS"+data ShapeDefinition =+  ShapeDefinition {+    shapeDefinitionListOfAlts :: [ShapeDefinition_ListOfAlts_Elmt],+    shapeDefinitionTripleExpression :: (Maybe TripleExpression),+    shapeDefinitionListOfAnnotation :: [Annotation],+    shapeDefinitionSemanticActions :: SemanticActions}+  deriving (Eq, Ord, Read, Show)+_ShapeDefinition = Core.Name "hydra.shex.syntax.ShapeDefinition"+_ShapeDefinition_listOfAlts = Core.Name "listOfAlts"+_ShapeDefinition_TripleExpression = Core.Name "TripleExpression"+_ShapeDefinition_listOfAnnotation = Core.Name "listOfAnnotation"+_ShapeDefinition_SemanticActions = Core.Name "SemanticActions"+data ShapeDefinition_ListOfAlts_Elmt =+  ShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |+  ShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |+  ShapeDefinition_ListOfAlts_ElmtCLOSED+  deriving (Eq, Ord, Read, Show)+_ShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.ShapeDefinition_ListOfAlts_Elmt"+_ShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"+_ShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"+_ShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"+data InlineShapeDefinition =+  InlineShapeDefinition {+    inlineShapeDefinitionListOfAlts :: [InlineShapeDefinition_ListOfAlts_Elmt],+    inlineShapeDefinitionTripleExpression :: (Maybe TripleExpression)}+  deriving (Eq, Ord, Read, Show)+_InlineShapeDefinition = Core.Name "hydra.shex.syntax.InlineShapeDefinition"+_InlineShapeDefinition_listOfAlts = Core.Name "listOfAlts"+_InlineShapeDefinition_TripleExpression = Core.Name "TripleExpression"+data InlineShapeDefinition_ListOfAlts_Elmt =+  InlineShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |+  InlineShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |+  InlineShapeDefinition_ListOfAlts_ElmtCLOSED+  deriving (Eq, Ord, Read, Show)+_InlineShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.InlineShapeDefinition_ListOfAlts_Elmt"+_InlineShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"+_InlineShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"+_InlineShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"+newtype ExtraPropertySet =+  ExtraPropertySet {+    unExtraPropertySet :: [Predicate]}+  deriving (Eq, Ord, Read, Show)+_ExtraPropertySet = Core.Name "hydra.shex.syntax.ExtraPropertySet"+newtype TripleExpression =+  TripleExpression {+    unTripleExpression :: OneOfTripleExpr}+  deriving (Eq, Ord, Read, Show)+_TripleExpression = Core.Name "hydra.shex.syntax.TripleExpression"+data OneOfTripleExpr =+  OneOfTripleExprGroupTripleExpr GroupTripleExpr |+  OneOfTripleExprMultiElementOneOf MultiElementOneOf+  deriving (Eq, Ord, Read, Show)+_OneOfTripleExpr = Core.Name "hydra.shex.syntax.OneOfTripleExpr"+_OneOfTripleExpr_GroupTripleExpr = Core.Name "GroupTripleExpr"+_OneOfTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"+data MultiElementOneOf =+  MultiElementOneOf {+    multiElementOneOfGroupTripleExpr :: GroupTripleExpr,+    multiElementOneOfListOfSequence :: [GroupTripleExpr]}+  deriving (Eq, Ord, Read, Show)+_MultiElementOneOf = Core.Name "hydra.shex.syntax.MultiElementOneOf"+_MultiElementOneOf_GroupTripleExpr = Core.Name "GroupTripleExpr"+_MultiElementOneOf_listOfSequence = Core.Name "listOfSequence"+data InnerTripleExpr =+  InnerTripleExprMultiElementGroup MultiElementGroup |+  InnerTripleExprMultiElementOneOf MultiElementOneOf+  deriving (Eq, Ord, Read, Show)+_InnerTripleExpr = Core.Name "hydra.shex.syntax.InnerTripleExpr"+_InnerTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"+_InnerTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"+data GroupTripleExpr =+  GroupTripleExprSingleElementGroup SingleElementGroup |+  GroupTripleExprMultiElementGroup MultiElementGroup+  deriving (Eq, Ord, Read, Show)+_GroupTripleExpr = Core.Name "hydra.shex.syntax.GroupTripleExpr"+_GroupTripleExpr_SingleElementGroup = Core.Name "SingleElementGroup"+_GroupTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"+data SingleElementGroup =+  SingleElementGroup {+    singleElementGroupUnaryTripleExpr :: UnaryTripleExpr,+    singleElementGroupSemi :: (Maybe ())}+  deriving (Eq, Ord, Read, Show)+_SingleElementGroup = Core.Name "hydra.shex.syntax.SingleElementGroup"+_SingleElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"+_SingleElementGroup_Semi = Core.Name "Semi"+data MultiElementGroup =+  MultiElementGroup {+    multiElementGroupUnaryTripleExpr :: UnaryTripleExpr,+    multiElementGroupListOfSequence :: [UnaryTripleExpr],+    multiElementGroupSemi :: (Maybe ())}+  deriving (Eq, Ord, Read, Show)+_MultiElementGroup = Core.Name "hydra.shex.syntax.MultiElementGroup"+_MultiElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"+_MultiElementGroup_listOfSequence = Core.Name "listOfSequence"+_MultiElementGroup_Semi = Core.Name "Semi"+data UnaryTripleExpr =+  UnaryTripleExprSequence UnaryTripleExpr_Sequence |+  UnaryTripleExprInclude Include+  deriving (Eq, Ord, Read, Show)+_UnaryTripleExpr = Core.Name "hydra.shex.syntax.UnaryTripleExpr"+_UnaryTripleExpr_sequence = Core.Name "sequence"+_UnaryTripleExpr_Include = Core.Name "Include"+data UnaryTripleExpr_Sequence =+  UnaryTripleExpr_Sequence {+    unaryTripleExpr_SequenceSequence :: (Maybe TripleExprLabel),+    unaryTripleExpr_SequenceAlts :: UnaryTripleExpr_Sequence_Alts}+  deriving (Eq, Ord, Read, Show)+_UnaryTripleExpr_Sequence = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence"+_UnaryTripleExpr_Sequence_Sequence = Core.Name "Sequence"+_UnaryTripleExpr_Sequence_alts = Core.Name "alts"+data UnaryTripleExpr_Sequence_Alts =+  UnaryTripleExpr_Sequence_AltsTripleConstraint TripleConstraint |+  UnaryTripleExpr_Sequence_AltsBracketedTripleExpr BracketedTripleExpr+  deriving (Eq, Ord, Read, Show)+_UnaryTripleExpr_Sequence_Alts = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence_Alts"+_UnaryTripleExpr_Sequence_Alts_TripleConstraint = Core.Name "TripleConstraint"+_UnaryTripleExpr_Sequence_Alts_BracketedTripleExpr = Core.Name "BracketedTripleExpr"+data BracketedTripleExpr =+  BracketedTripleExpr {+    bracketedTripleExprInnerTripleExpr :: InnerTripleExpr,+    bracketedTripleExprCardinality :: (Maybe Cardinality),+    bracketedTripleExprListOfAnnotation :: [Annotation],+    bracketedTripleExprSemanticActions :: SemanticActions}+  deriving (Eq, Ord, Read, Show)+_BracketedTripleExpr = Core.Name "hydra.shex.syntax.BracketedTripleExpr"+_BracketedTripleExpr_InnerTripleExpr = Core.Name "InnerTripleExpr"+_BracketedTripleExpr_Cardinality = Core.Name "Cardinality"+_BracketedTripleExpr_listOfAnnotation = Core.Name "listOfAnnotation"+_BracketedTripleExpr_SemanticActions = Core.Name "SemanticActions"+data TripleConstraint =+  TripleConstraint {+    tripleConstraintSenseFlags :: (Maybe SenseFlags),+    tripleConstraintPredicate :: Predicate,+    tripleConstraintInlineShapeExpression :: InlineShapeExpression,+    tripleConstraintCardinality :: (Maybe Cardinality),+    tripleConstraintListOfAnnotation :: [Annotation],+    tripleConstraintSemanticActions :: SemanticActions}+  deriving (Eq, Ord, Read, Show)+_TripleConstraint = Core.Name "hydra.shex.syntax.TripleConstraint"+_TripleConstraint_SenseFlags = Core.Name "SenseFlags"+_TripleConstraint_Predicate = Core.Name "Predicate"+_TripleConstraint_InlineShapeExpression = Core.Name "InlineShapeExpression"+_TripleConstraint_Cardinality = Core.Name "Cardinality"+_TripleConstraint_listOfAnnotation = Core.Name "listOfAnnotation"+_TripleConstraint_SemanticActions = Core.Name "SemanticActions"+data Cardinality =+  CardinalityAst |+  CardinalityPlus |+  CardinalityQuest |+  CardinalityRepeatRange RepeatRange+  deriving (Eq, Ord, Read, Show)+_Cardinality = Core.Name "hydra.shex.syntax.Cardinality"+_Cardinality_Ast = Core.Name "Ast"+_Cardinality_Plus = Core.Name "Plus"+_Cardinality_Quest = Core.Name "Quest"+_Cardinality_RepeatRange = Core.Name "RepeatRange"+newtype SenseFlags =+  SenseFlags {+    unSenseFlags :: ()}+  deriving (Eq, Ord, Read, Show)+_SenseFlags = Core.Name "hydra.shex.syntax.SenseFlags"+newtype ValueSet =+  ValueSet {+    unValueSet :: [ValueSetValue]}+  deriving (Eq, Ord, Read, Show)+_ValueSet = Core.Name "hydra.shex.syntax.ValueSet"+data ValueSetValue =+  ValueSetValueIriRange IriRange |+  ValueSetValueLiteral Literal+  deriving (Eq, Ord, Read, Show)+_ValueSetValue = Core.Name "hydra.shex.syntax.ValueSetValue"+_ValueSetValue_IriRange = Core.Name "IriRange"+_ValueSetValue_Literal = Core.Name "Literal"+data IriRange =+  IriRangeSequence IriRange_Sequence |+  IriRangeSequence2 [Exclusion]+  deriving (Eq, Ord, Read, Show)+_IriRange = Core.Name "hydra.shex.syntax.IriRange"+_IriRange_sequence = Core.Name "sequence"+_IriRange_sequence2 = Core.Name "sequence2"+data IriRange_Sequence =+  IriRange_Sequence {+    iriRange_SequenceIri :: Iri,+    iriRange_SequenceSequence :: (Maybe [Exclusion])}+  deriving (Eq, Ord, Read, Show)+_IriRange_Sequence = Core.Name "hydra.shex.syntax.IriRange_Sequence"+_IriRange_Sequence_Iri = Core.Name "Iri"+_IriRange_Sequence_Sequence = Core.Name "Sequence"+newtype Exclusion =+  Exclusion {+    unExclusion :: Iri}+  deriving (Eq, Ord, Read, Show)+_Exclusion = Core.Name "hydra.shex.syntax.Exclusion"+newtype Include =+  Include {+    unInclude :: TripleExprLabel}+  deriving (Eq, Ord, Read, Show)+_Include = Core.Name "hydra.shex.syntax.Include"+data Annotation =+  Annotation {+    annotationPredicate :: Predicate,+    annotationAlts :: Annotation_Alts}+  deriving (Eq, Ord, Read, Show)+_Annotation = Core.Name "hydra.shex.syntax.Annotation"+_Annotation_Predicate = Core.Name "Predicate"+_Annotation_alts = Core.Name "alts"+data Annotation_Alts =+  Annotation_AltsIri Iri |+  Annotation_AltsLiteral Literal+  deriving (Eq, Ord, Read, Show)+_Annotation_Alts = Core.Name "hydra.shex.syntax.Annotation_Alts"+_Annotation_Alts_Iri = Core.Name "Iri"+_Annotation_Alts_Literal = Core.Name "Literal"+newtype SemanticActions =+  SemanticActions {+    unSemanticActions :: [CodeDecl]}+  deriving (Eq, Ord, Read, Show)+_SemanticActions = Core.Name "hydra.shex.syntax.SemanticActions"+data CodeDecl =+  CodeDecl {+    codeDeclIri :: Iri,+    codeDeclAlts :: CodeDecl_Alts}+  deriving (Eq, Ord, Read, Show)+_CodeDecl = Core.Name "hydra.shex.syntax.CodeDecl"+_CodeDecl_Iri = Core.Name "Iri"+_CodeDecl_alts = Core.Name "alts"+data CodeDecl_Alts =+  CodeDecl_AltsCode Code |+  CodeDecl_AltsPercnt+  deriving (Eq, Ord, Read, Show)+_CodeDecl_Alts = Core.Name "hydra.shex.syntax.CodeDecl_Alts"+_CodeDecl_Alts_Code = Core.Name "Code"+_CodeDecl_Alts_Percnt = Core.Name "Percnt"+data Literal =+  LiteralRdfLiteral RdfLiteral |+  LiteralNumericLiteral NumericLiteral |+  LiteralBooleanLiteral BooleanLiteral+  deriving (Eq, Ord, Read, Show)+_Literal = Core.Name "hydra.shex.syntax.Literal"+_Literal_RdfLiteral = Core.Name "RdfLiteral"+_Literal_NumericLiteral = Core.Name "NumericLiteral"+_Literal_BooleanLiteral = Core.Name "BooleanLiteral"+data Predicate =+  PredicateIri Iri |+  PredicateRdfType RdfType+  deriving (Eq, Ord, Read, Show)+_Predicate = Core.Name "hydra.shex.syntax.Predicate"+_Predicate_Iri = Core.Name "Iri"+_Predicate_RdfType = Core.Name "RdfType"+newtype Datatype =+  Datatype {+    unDatatype :: Iri}+  deriving (Eq, Ord, Read, Show)+_Datatype = Core.Name "hydra.shex.syntax.Datatype"+data ShapeExprLabel =+  ShapeExprLabelIri Iri |+  ShapeExprLabelBlankNode BlankNode+  deriving (Eq, Ord, Read, Show)+_ShapeExprLabel = Core.Name "hydra.shex.syntax.ShapeExprLabel"+_ShapeExprLabel_Iri = Core.Name "Iri"+_ShapeExprLabel_BlankNode = Core.Name "BlankNode"+data TripleExprLabel =+  TripleExprLabelIri Iri |+  TripleExprLabelBlankNode BlankNode+  deriving (Eq, Ord, Read, Show)+_TripleExprLabel = Core.Name "hydra.shex.syntax.TripleExprLabel"+_TripleExprLabel_Iri = Core.Name "Iri"+_TripleExprLabel_BlankNode = Core.Name "BlankNode"+data NumericLiteral =+  NumericLiteralInteger Integer_ |+  NumericLiteralDecimal Decimal |+  NumericLiteralDouble Double_+  deriving (Eq, Ord, Read, Show)+_NumericLiteral = Core.Name "hydra.shex.syntax.NumericLiteral"+_NumericLiteral_Integer = Core.Name "Integer"+_NumericLiteral_Decimal = Core.Name "Decimal"+_NumericLiteral_Double = Core.Name "Double"+data RdfLiteral =+  RdfLiteral {+    rdfLiteralString :: String_,+    rdfLiteralAlts :: (Maybe RdfLiteral_Alts_Option)}+  deriving (Eq, Ord, Read, Show)+_RdfLiteral = Core.Name "hydra.shex.syntax.RdfLiteral"+_RdfLiteral_String = Core.Name "String"+_RdfLiteral_Alts = Core.Name "Alts"+data RdfLiteral_Alts_Option =+  RdfLiteral_Alts_OptionLangTag LangTag |+  RdfLiteral_Alts_OptionSequence Datatype+  deriving (Eq, Ord, Read, Show)+_RdfLiteral_Alts_Option = Core.Name "hydra.shex.syntax.RdfLiteral_Alts_Option"+_RdfLiteral_Alts_Option_LangTag = Core.Name "LangTag"+_RdfLiteral_Alts_Option_sequence = Core.Name "sequence"+data BooleanLiteral =+  BooleanLiteralTrue |+  BooleanLiteralFalse+  deriving (Eq, Ord, Read, Show)+_BooleanLiteral = Core.Name "hydra.shex.syntax.BooleanLiteral"+_BooleanLiteral_True = Core.Name "True"+_BooleanLiteral_False = Core.Name "False"+data String_ =+  StringStringLiteral1 StringLiteral1 |+  StringStringLiteralLong1 StringLiteralLong1 |+  StringStringLiteral2 StringLiteral2 |+  StringStringLiteralLong2 StringLiteralLong2+  deriving (Eq, Ord, Read, Show)+_String = Core.Name "hydra.shex.syntax.String"+_String_StringLiteral1 = Core.Name "StringLiteral1"+_String_StringLiteralLong1 = Core.Name "StringLiteralLong1"+_String_StringLiteral2 = Core.Name "StringLiteral2"+_String_StringLiteralLong2 = Core.Name "StringLiteralLong2"+data Iri =+  IriIriRef IriRef |+  IriPrefixedName PrefixedName+  deriving (Eq, Ord, Read, Show)+_Iri = Core.Name "hydra.shex.syntax.Iri"+_Iri_IriRef = Core.Name "IriRef"+_Iri_PrefixedName = Core.Name "PrefixedName"+data PrefixedName =+  PrefixedNamePnameLn PnameLn |+  PrefixedNamePnameNs PnameNs+  deriving (Eq, Ord, Read, Show)+_PrefixedName = Core.Name "hydra.shex.syntax.PrefixedName"+_PrefixedName_PnameLn = Core.Name "PnameLn"+_PrefixedName_PnameNs = Core.Name "PnameNs"+newtype BlankNode =+  BlankNode {+    unBlankNode :: BlankNodeLabel}+  deriving (Eq, Ord, Read, Show)+_BlankNode = Core.Name "hydra.shex.syntax.BlankNode"+newtype IncludeSet =+  IncludeSet {+    unIncludeSet :: [ShapeExprLabel]}+  deriving (Eq, Ord, Read, Show)+_IncludeSet = Core.Name "hydra.shex.syntax.IncludeSet"+newtype Code =+  Code {+    unCode :: [Code_Elmt]}+  deriving (Eq, Ord, Read, Show)+_Code = Core.Name "hydra.shex.syntax.Code"+data Code_Elmt =+  Code_ElmtRegex String |+  Code_ElmtSequence String |+  Code_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_Code_Elmt = Core.Name "hydra.shex.syntax.Code_Elmt"+_Code_Elmt_regex = Core.Name "regex"+_Code_Elmt_sequence = Core.Name "sequence"+_Code_Elmt_Uchar = Core.Name "Uchar"+data RepeatRange =+  RepeatRange {+    repeatRangeInteger :: Integer_,+    repeatRangeSequence :: (Maybe (Maybe (Maybe RepeatRange_Sequence_Option_Option_Option)))}+  deriving (Eq, Ord, Read, Show)+_RepeatRange = Core.Name "hydra.shex.syntax.RepeatRange"+_RepeatRange_Integer = Core.Name "Integer"+_RepeatRange_Sequence = Core.Name "Sequence"+data RepeatRange_Sequence_Option_Option_Option =+  RepeatRange_Sequence_Option_Option_OptionInteger Integer_ |+  RepeatRange_Sequence_Option_Option_OptionAst+  deriving (Eq, Ord, Read, Show)+_RepeatRange_Sequence_Option_Option_Option = Core.Name "hydra.shex.syntax.RepeatRange_Sequence_Option_Option_Option"+_RepeatRange_Sequence_Option_Option_Option_Integer = Core.Name "Integer"+_RepeatRange_Sequence_Option_Option_Option_Ast = Core.Name "Ast"+newtype RdfType =+  RdfType {+    unRdfType :: ()}+  deriving (Eq, Ord, Read, Show)+_RdfType = Core.Name "hydra.shex.syntax.RdfType"+newtype IriRef =+  IriRef {+    unIriRef :: [IriRef_Elmt]}+  deriving (Eq, Ord, Read, Show)+_IriRef = Core.Name "hydra.shex.syntax.IriRef"+data IriRef_Elmt =+  IriRef_ElmtRegex String |+  IriRef_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_IriRef_Elmt = Core.Name "hydra.shex.syntax.IriRef_Elmt"+_IriRef_Elmt_regex = Core.Name "regex"+_IriRef_Elmt_Uchar = Core.Name "Uchar"+newtype PnameNs =+  PnameNs {+    unPnameNs :: (Maybe PnPrefix)}+  deriving (Eq, Ord, Read, Show)+_PnameNs = Core.Name "hydra.shex.syntax.PnameNs"+data PnameLn =+  PnameLn {+    pnameLnPnameNs :: PnameNs,+    pnameLnPnLocal :: PnLocal}+  deriving (Eq, Ord, Read, Show)+_PnameLn = Core.Name "hydra.shex.syntax.PnameLn"+_PnameLn_PnameNs = Core.Name "PnameNs"+_PnameLn_PnLocal = Core.Name "PnLocal"+newtype AtpNameNs =+  AtpNameNs {+    unAtpNameNs :: (Maybe PnPrefix)}+  deriving (Eq, Ord, Read, Show)+_AtpNameNs = Core.Name "hydra.shex.syntax.AtpNameNs"+data AtpNameLn =+  AtpNameLn {+    atpNameLnPnameNs :: PnameNs,+    atpNameLnPnLocal :: PnLocal}+  deriving (Eq, Ord, Read, Show)+_AtpNameLn = Core.Name "hydra.shex.syntax.AtpNameLn"+_AtpNameLn_PnameNs = Core.Name "PnameNs"+_AtpNameLn_PnLocal = Core.Name "PnLocal"+data Regexp =+  Regexp {+    regexpListOfAlts :: [Regexp_ListOfAlts_Elmt],+    regexpListOfRegex :: [String]}+  deriving (Eq, Ord, Read, Show)+_Regexp = Core.Name "hydra.shex.syntax.Regexp"+_Regexp_listOfAlts = Core.Name "listOfAlts"+_Regexp_listOfRegex = Core.Name "listOfRegex"+data Regexp_ListOfAlts_Elmt =+  Regexp_ListOfAlts_ElmtRegex String |+  Regexp_ListOfAlts_ElmtSequence String |+  Regexp_ListOfAlts_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_Regexp_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.Regexp_ListOfAlts_Elmt"+_Regexp_ListOfAlts_Elmt_regex = Core.Name "regex"+_Regexp_ListOfAlts_Elmt_sequence = Core.Name "sequence"+_Regexp_ListOfAlts_Elmt_Uchar = Core.Name "Uchar"+data BlankNodeLabel =+  BlankNodeLabel {+    blankNodeLabelAlts :: BlankNodeLabel_Alts,+    blankNodeLabelListOfAlts :: (Maybe [BlankNodeLabel_ListOfAlts_Option_Elmt]),+    blankNodeLabelPnChars :: PnChars}+  deriving (Eq, Ord, Read, Show)+_BlankNodeLabel = Core.Name "hydra.shex.syntax.BlankNodeLabel"+_BlankNodeLabel_alts = Core.Name "alts"+_BlankNodeLabel_ListOfAlts = Core.Name "ListOfAlts"+_BlankNodeLabel_PnChars = Core.Name "PnChars"+data BlankNodeLabel_Alts =+  BlankNodeLabel_AltsPnCharsU PnCharsU |+  BlankNodeLabel_AltsRegex String+  deriving (Eq, Ord, Read, Show)+_BlankNodeLabel_Alts = Core.Name "hydra.shex.syntax.BlankNodeLabel_Alts"+_BlankNodeLabel_Alts_PnCharsU = Core.Name "PnCharsU"+_BlankNodeLabel_Alts_regex = Core.Name "regex"+data BlankNodeLabel_ListOfAlts_Option_Elmt =+  BlankNodeLabel_ListOfAlts_Option_ElmtPnChars PnChars |+  BlankNodeLabel_ListOfAlts_Option_ElmtPeriod+  deriving (Eq, Ord, Read, Show)+_BlankNodeLabel_ListOfAlts_Option_Elmt = Core.Name "hydra.shex.syntax.BlankNodeLabel_ListOfAlts_Option_Elmt"+_BlankNodeLabel_ListOfAlts_Option_Elmt_PnChars = Core.Name "PnChars"+_BlankNodeLabel_ListOfAlts_Option_Elmt_Period = Core.Name "Period"+newtype LangTag =+  LangTag {+    unLangTag :: String}+  deriving (Eq, Ord, Read, Show)+_LangTag = Core.Name "hydra.shex.syntax.LangTag"+newtype Integer_ =+  Integer_ {+    unInteger :: String}+  deriving (Eq, Ord, Read, Show)+_Integer = Core.Name "hydra.shex.syntax.Integer"+newtype Decimal =+  Decimal {+    unDecimal :: String}+  deriving (Eq, Ord, Read, Show)+_Decimal = Core.Name "hydra.shex.syntax.Decimal"+newtype Double_ =+  Double_ {+    unDouble :: String}+  deriving (Eq, Ord, Read, Show)+_Double = Core.Name "hydra.shex.syntax.Double"+newtype StringLiteral1 =+  StringLiteral1 {+    unStringLiteral1 :: [StringLiteral1_Elmt]}+  deriving (Eq, Ord, Read, Show)+_StringLiteral1 = Core.Name "hydra.shex.syntax.StringLiteral1"+data StringLiteral1_Elmt =+  StringLiteral1_ElmtRegex String |+  StringLiteral1_ElmtEchar Echar |+  StringLiteral1_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_StringLiteral1_Elmt = Core.Name "hydra.shex.syntax.StringLiteral1_Elmt"+_StringLiteral1_Elmt_regex = Core.Name "regex"+_StringLiteral1_Elmt_Echar = Core.Name "Echar"+_StringLiteral1_Elmt_Uchar = Core.Name "Uchar"+newtype StringLiteral2 =+  StringLiteral2 {+    unStringLiteral2 :: [StringLiteral2_Elmt]}+  deriving (Eq, Ord, Read, Show)+_StringLiteral2 = Core.Name "hydra.shex.syntax.StringLiteral2"+data StringLiteral2_Elmt =+  StringLiteral2_ElmtRegex String |+  StringLiteral2_ElmtEchar Echar |+  StringLiteral2_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_StringLiteral2_Elmt = Core.Name "hydra.shex.syntax.StringLiteral2_Elmt"+_StringLiteral2_Elmt_regex = Core.Name "regex"+_StringLiteral2_Elmt_Echar = Core.Name "Echar"+_StringLiteral2_Elmt_Uchar = Core.Name "Uchar"+newtype StringLiteralLong1 =+  StringLiteralLong1 {+    unStringLiteralLong1 :: [StringLiteralLong1_Elmt]}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong1 = Core.Name "hydra.shex.syntax.StringLiteralLong1"+data StringLiteralLong1_Elmt =+  StringLiteralLong1_ElmtSequence StringLiteralLong1_Elmt_Sequence |+  StringLiteralLong1_ElmtEchar Echar |+  StringLiteralLong1_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong1_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt"+_StringLiteralLong1_Elmt_sequence = Core.Name "sequence"+_StringLiteralLong1_Elmt_Echar = Core.Name "Echar"+_StringLiteralLong1_Elmt_Uchar = Core.Name "Uchar"+data StringLiteralLong1_Elmt_Sequence =+  StringLiteralLong1_Elmt_Sequence {+    stringLiteralLong1_Elmt_SequenceAlts :: (Maybe StringLiteralLong1_Elmt_Sequence_Alts_Option),+    stringLiteralLong1_Elmt_SequenceRegex :: String}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong1_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence"+_StringLiteralLong1_Elmt_Sequence_Alts = Core.Name "Alts"+_StringLiteralLong1_Elmt_Sequence_regex = Core.Name "regex"+data StringLiteralLong1_Elmt_Sequence_Alts_Option =+  StringLiteralLong1_Elmt_Sequence_Alts_OptionApos |+  StringLiteralLong1_Elmt_Sequence_Alts_OptionSequence StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong1_Elmt_Sequence_Alts_Option =+    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option"+_StringLiteralLong1_Elmt_Sequence_Alts_Option_Apos = Core.Name "Apos"+_StringLiteralLong1_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"+data StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =+  StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence {}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =+    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence"+newtype StringLiteralLong2 =+  StringLiteralLong2 {+    unStringLiteralLong2 :: [StringLiteralLong2_Elmt]}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong2 = Core.Name "hydra.shex.syntax.StringLiteralLong2"+data StringLiteralLong2_Elmt =+  StringLiteralLong2_ElmtSequence StringLiteralLong2_Elmt_Sequence |+  StringLiteralLong2_ElmtEchar Echar |+  StringLiteralLong2_ElmtUchar Uchar+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong2_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt"+_StringLiteralLong2_Elmt_sequence = Core.Name "sequence"+_StringLiteralLong2_Elmt_Echar = Core.Name "Echar"+_StringLiteralLong2_Elmt_Uchar = Core.Name "Uchar"+data StringLiteralLong2_Elmt_Sequence =+  StringLiteralLong2_Elmt_Sequence {+    stringLiteralLong2_Elmt_SequenceAlts :: (Maybe StringLiteralLong2_Elmt_Sequence_Alts_Option),+    stringLiteralLong2_Elmt_SequenceRegex :: String}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong2_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence"+_StringLiteralLong2_Elmt_Sequence_Alts = Core.Name "Alts"+_StringLiteralLong2_Elmt_Sequence_regex = Core.Name "regex"+data StringLiteralLong2_Elmt_Sequence_Alts_Option =+  StringLiteralLong2_Elmt_Sequence_Alts_OptionQuot |+  StringLiteralLong2_Elmt_Sequence_Alts_OptionSequence StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong2_Elmt_Sequence_Alts_Option =+    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option"+_StringLiteralLong2_Elmt_Sequence_Alts_Option_Quot = Core.Name "Quot"+_StringLiteralLong2_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"+data StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =+  StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence {}+  deriving (Eq, Ord, Read, Show)+_StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =+    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence"+data Uchar =+  UcharSequence Uchar_Sequence |+  UcharSequence2 Uchar_Sequence2+  deriving (Eq, Ord, Read, Show)+_Uchar = Core.Name "hydra.shex.syntax.Uchar"+_Uchar_sequence = Core.Name "sequence"+_Uchar_sequence2 = Core.Name "sequence2"+data Uchar_Sequence =+  Uchar_Sequence {+    uchar_SequenceHex :: Hex,+    uchar_SequenceHex2 :: Hex,+    uchar_SequenceHex3 :: Hex,+    uchar_SequenceHex4 :: Hex}+  deriving (Eq, Ord, Read, Show)+_Uchar_Sequence = Core.Name "hydra.shex.syntax.Uchar_Sequence"+_Uchar_Sequence_Hex = Core.Name "Hex"+_Uchar_Sequence_Hex2 = Core.Name "Hex2"+_Uchar_Sequence_Hex3 = Core.Name "Hex3"+_Uchar_Sequence_Hex4 = Core.Name "Hex4"+data Uchar_Sequence2 =+  Uchar_Sequence2 {+    uchar_Sequence2Hex :: Hex,+    uchar_Sequence2Hex2 :: Hex,+    uchar_Sequence2Hex3 :: Hex,+    uchar_Sequence2Hex4 :: Hex,+    uchar_Sequence2Hex5 :: Hex,+    uchar_Sequence2Hex6 :: Hex,+    uchar_Sequence2Hex7 :: Hex,+    uchar_Sequence2Hex8 :: Hex}+  deriving (Eq, Ord, Read, Show)+_Uchar_Sequence2 = Core.Name "hydra.shex.syntax.Uchar_Sequence2"+_Uchar_Sequence2_Hex = Core.Name "Hex"+_Uchar_Sequence2_Hex2 = Core.Name "Hex2"+_Uchar_Sequence2_Hex3 = Core.Name "Hex3"+_Uchar_Sequence2_Hex4 = Core.Name "Hex4"+_Uchar_Sequence2_Hex5 = Core.Name "Hex5"+_Uchar_Sequence2_Hex6 = Core.Name "Hex6"+_Uchar_Sequence2_Hex7 = Core.Name "Hex7"+_Uchar_Sequence2_Hex8 = Core.Name "Hex8"+newtype Echar =+  Echar {+    unEchar :: String}+  deriving (Eq, Ord, Read, Show)+_Echar = Core.Name "hydra.shex.syntax.Echar"+data PnCharsBase =+  PnCharsBaseRegex String |+  PnCharsBaseRegex2 String+  deriving (Eq, Ord, Read, Show)+_PnCharsBase = Core.Name "hydra.shex.syntax.PnCharsBase"+_PnCharsBase_regex = Core.Name "regex"+_PnCharsBase_regex2 = Core.Name "regex2"+data PnCharsU =+  PnCharsUPnCharsBase PnCharsBase |+  PnCharsULowbar+  deriving (Eq, Ord, Read, Show)+_PnCharsU = Core.Name "hydra.shex.syntax.PnCharsU"+_PnCharsU_PnCharsBase = Core.Name "PnCharsBase"+_PnCharsU_Lowbar = Core.Name "Lowbar"+data PnChars =+  PnCharsPnCharsU PnCharsU |+  PnCharsMinus |+  PnCharsRegex String+  deriving (Eq, Ord, Read, Show)+_PnChars = Core.Name "hydra.shex.syntax.PnChars"+_PnChars_PnCharsU = Core.Name "PnCharsU"+_PnChars_Minus = Core.Name "Minus"+_PnChars_regex = Core.Name "regex"+data PnPrefix =+  PnPrefix {+    pnPrefixPnCharsBase :: PnCharsBase,+    pnPrefixSequence :: (Maybe PnPrefix_Sequence_Option)}+  deriving (Eq, Ord, Read, Show)+_PnPrefix = Core.Name "hydra.shex.syntax.PnPrefix"+_PnPrefix_PnCharsBase = Core.Name "PnCharsBase"+_PnPrefix_Sequence = Core.Name "Sequence"+data PnPrefix_Sequence_Option =+  PnPrefix_Sequence_Option {+    pnPrefix_Sequence_OptionAlts :: PnPrefix_Sequence_Option_Alts,+    pnPrefix_Sequence_OptionPnChars :: PnChars}+  deriving (Eq, Ord, Read, Show)+_PnPrefix_Sequence_Option = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option"+_PnPrefix_Sequence_Option_alts = Core.Name "alts"+_PnPrefix_Sequence_Option_PnChars = Core.Name "PnChars"+data PnPrefix_Sequence_Option_Alts =+  PnPrefix_Sequence_Option_AltsPnChars PnChars |+  PnPrefix_Sequence_Option_AltsPeriod+  deriving (Eq, Ord, Read, Show)+_PnPrefix_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option_Alts"+_PnPrefix_Sequence_Option_Alts_PnChars = Core.Name "PnChars"+_PnPrefix_Sequence_Option_Alts_Period = Core.Name "Period"+data PnLocal =+  PnLocal {+    pnLocalAlts :: PnLocal_Alts,+    pnLocalSequence :: (Maybe PnLocal_Sequence_Option)}+  deriving (Eq, Ord, Read, Show)+_PnLocal = Core.Name "hydra.shex.syntax.PnLocal"+_PnLocal_alts = Core.Name "alts"+_PnLocal_Sequence = Core.Name "Sequence"+data PnLocal_Alts =+  PnLocal_AltsPnCharsU PnCharsU |+  PnLocal_AltsColon |+  PnLocal_AltsRegex String |+  PnLocal_AltsPlx Plx+  deriving (Eq, Ord, Read, Show)+_PnLocal_Alts = Core.Name "hydra.shex.syntax.PnLocal_Alts"+_PnLocal_Alts_PnCharsU = Core.Name "PnCharsU"+_PnLocal_Alts_Colon = Core.Name "Colon"+_PnLocal_Alts_regex = Core.Name "regex"+_PnLocal_Alts_Plx = Core.Name "Plx"+data PnLocal_Sequence_Option =+  PnLocal_Sequence_Option {+    pnLocal_Sequence_OptionListOfAlts :: [PnLocal_Sequence_Option_ListOfAlts_Elmt],+    pnLocal_Sequence_OptionAlts :: PnLocal_Sequence_Option_Alts}+  deriving (Eq, Ord, Read, Show)+_PnLocal_Sequence_Option = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option"+_PnLocal_Sequence_Option_listOfAlts = Core.Name "listOfAlts"+_PnLocal_Sequence_Option_alts = Core.Name "alts"+data PnLocal_Sequence_Option_ListOfAlts_Elmt =+  PnLocal_Sequence_Option_ListOfAlts_ElmtPnChars PnChars |+  PnLocal_Sequence_Option_ListOfAlts_ElmtPeriod |+  PnLocal_Sequence_Option_ListOfAlts_ElmtColon |+  PnLocal_Sequence_Option_ListOfAlts_ElmtPlx Plx+  deriving (Eq, Ord, Read, Show)+_PnLocal_Sequence_Option_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_ListOfAlts_Elmt"+_PnLocal_Sequence_Option_ListOfAlts_Elmt_PnChars = Core.Name "PnChars"+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Period = Core.Name "Period"+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Colon = Core.Name "Colon"+_PnLocal_Sequence_Option_ListOfAlts_Elmt_Plx = Core.Name "Plx"+data PnLocal_Sequence_Option_Alts =+  PnLocal_Sequence_Option_AltsPnChars PnChars |+  PnLocal_Sequence_Option_AltsColon |+  PnLocal_Sequence_Option_AltsPlx Plx+  deriving (Eq, Ord, Read, Show)+_PnLocal_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_Alts"+_PnLocal_Sequence_Option_Alts_PnChars = Core.Name "PnChars"+_PnLocal_Sequence_Option_Alts_Colon = Core.Name "Colon"+_PnLocal_Sequence_Option_Alts_Plx = Core.Name "Plx"+data Plx =+  PlxPercent Percent |+  PlxPnLocalEsc PnLocalEsc+  deriving (Eq, Ord, Read, Show)+_Plx = Core.Name "hydra.shex.syntax.Plx"+_Plx_Percent = Core.Name "Percent"+_Plx_PnLocalEsc = Core.Name "PnLocalEsc"+data Percent =+  Percent {+    percentHex :: Hex,+    percentHex2 :: Hex}+  deriving (Eq, Ord, Read, Show)+_Percent = Core.Name "hydra.shex.syntax.Percent"+_Percent_Hex = Core.Name "Hex"+_Percent_Hex2 = Core.Name "Hex2"+newtype Hex =+  Hex {+    unHex :: String}+  deriving (Eq, Ord, Read, Show)+_Hex = Core.Name "hydra.shex.syntax.Hex"+newtype PnLocalEsc =+  PnLocalEsc {+    unPnLocalEsc :: String}+  deriving (Eq, Ord, Read, Show)+_PnLocalEsc = Core.Name "hydra.shex.syntax.PnLocalEsc"

@@ -0,0 +1,329 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A partial XML Schema model, focusing on datatypes. All simple datatypes (i.e. xsd:anySimpleType and below) are included.+-- | See: https://www.w3.org/TR/xmlschema-2+-- | Note: for most of the XML Schema datatype definitions included here, the associated Hydra type is simply+-- |       the string type. Exceptions are made for xsd:boolean and most of the numeric types, where there is a clearly+-- |       corresponding Hydra literal type.++module Hydra.Xml.Schema 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.Int as I+newtype AnySimpleType =+  AnySimpleType {+    unAnySimpleType :: String}+  deriving (Eq, Ord, Read, Show)+_AnySimpleType = Core.Name "hydra.xml.schema.AnySimpleType"+newtype AnyType =+  AnyType {+    unAnyType :: String}+  deriving (Eq, Ord, Read, Show)+_AnyType = Core.Name "hydra.xml.schema.AnyType"+newtype AnyURI =+  AnyURI {+    unAnyURI :: String}+  deriving (Eq, Ord, Read, Show)+_AnyURI = Core.Name "hydra.xml.schema.AnyURI"+newtype Base64Binary =+  Base64Binary {+    unBase64Binary :: String}+  deriving (Eq, Ord, Read, Show)+_Base64Binary = Core.Name "hydra.xml.schema.Base64Binary"+newtype Boolean =+  Boolean {+    unBoolean :: Bool}+  deriving (Eq, Ord, Read, Show)+_Boolean = Core.Name "hydra.xml.schema.Boolean"+newtype Byte =+  Byte {+    unByte :: I.Int8}+  deriving (Eq, Ord, Read, Show)+_Byte = Core.Name "hydra.xml.schema.Byte"+newtype Date =+  Date {+    unDate :: String}+  deriving (Eq, Ord, Read, Show)+_Date = Core.Name "hydra.xml.schema.Date"+newtype DateTime =+  DateTime {+    unDateTime :: String}+  deriving (Eq, Ord, Read, Show)+_DateTime = Core.Name "hydra.xml.schema.DateTime"+newtype Decimal =+  Decimal {+    unDecimal :: String}+  deriving (Eq, Ord, Read, Show)+_Decimal = Core.Name "hydra.xml.schema.Decimal"+newtype Double_ =+  Double_ {+    unDouble :: Double}+  deriving (Eq, Ord, Read, Show)+_Double = Core.Name "hydra.xml.schema.Double"+newtype Duration =+  Duration {+    unDuration :: String}+  deriving (Eq, Ord, Read, Show)+_Duration = Core.Name "hydra.xml.schema.Duration"+newtype ENTITIES =+  ENTITIES {+    unENTITIES :: String}+  deriving (Eq, Ord, Read, Show)+_ENTITIES = Core.Name "hydra.xml.schema.ENTITIES"+newtype ENTITY =+  ENTITY {+    unENTITY :: String}+  deriving (Eq, Ord, Read, Show)+_ENTITY = Core.Name "hydra.xml.schema.ENTITY"+newtype Float_ =+  Float_ {+    unFloat :: Float}+  deriving (Eq, Ord, Read, Show)+_Float = Core.Name "hydra.xml.schema.Float"+newtype GDay =+  GDay {+    unGDay :: String}+  deriving (Eq, Ord, Read, Show)+_GDay = Core.Name "hydra.xml.schema.GDay"+newtype GMonth =+  GMonth {+    unGMonth :: String}+  deriving (Eq, Ord, Read, Show)+_GMonth = Core.Name "hydra.xml.schema.GMonth"+newtype GMonthDay =+  GMonthDay {+    unGMonthDay :: String}+  deriving (Eq, Ord, Read, Show)+_GMonthDay = Core.Name "hydra.xml.schema.GMonthDay"+newtype GYear =+  GYear {+    unGYear :: String}+  deriving (Eq, Ord, Read, Show)+_GYear = Core.Name "hydra.xml.schema.GYear"+newtype GYearMonth =+  GYearMonth {+    unGYearMonth :: String}+  deriving (Eq, Ord, Read, Show)+_GYearMonth = Core.Name "hydra.xml.schema.GYearMonth"+newtype HexBinary =+  HexBinary {+    unHexBinary :: String}+  deriving (Eq, Ord, Read, Show)+_HexBinary = Core.Name "hydra.xml.schema.HexBinary"+newtype ID =+  ID {+    unID :: String}+  deriving (Eq, Ord, Read, Show)+_ID = Core.Name "hydra.xml.schema.ID"+newtype IDREF =+  IDREF {+    unIDREF :: String}+  deriving (Eq, Ord, Read, Show)+_IDREF = Core.Name "hydra.xml.schema.IDREF"+newtype IDREFS =+  IDREFS {+    unIDREFS :: String}+  deriving (Eq, Ord, Read, Show)+_IDREFS = Core.Name "hydra.xml.schema.IDREFS"+newtype Int_ =+  Int_ {+    unInt :: Int}+  deriving (Eq, Ord, Read, Show)+_Int = Core.Name "hydra.xml.schema.Int"+newtype Integer_ =+  Integer_ {+    unInteger :: Integer}+  deriving (Eq, Ord, Read, Show)+_Integer = Core.Name "hydra.xml.schema.Integer"+newtype Language =+  Language {+    unLanguage :: String}+  deriving (Eq, Ord, Read, Show)+_Language = Core.Name "hydra.xml.schema.Language"+newtype Long =+  Long {+    unLong :: I.Int64}+  deriving (Eq, Ord, Read, Show)+_Long = Core.Name "hydra.xml.schema.Long"+newtype NMTOKEN =+  NMTOKEN {+    unNMTOKEN :: String}+  deriving (Eq, Ord, Read, Show)+_NMTOKEN = Core.Name "hydra.xml.schema.NMTOKEN"+newtype NOTATION =+  NOTATION {+    unNOTATION :: String}+  deriving (Eq, Ord, Read, Show)+_NOTATION = Core.Name "hydra.xml.schema.NOTATION"+newtype Name =+  Name {+    unName :: String}+  deriving (Eq, Ord, Read, Show)+_Name = Core.Name "hydra.xml.schema.Name"+newtype NegativeInteger =+  NegativeInteger {+    unNegativeInteger :: Integer}+  deriving (Eq, Ord, Read, Show)+_NegativeInteger = Core.Name "hydra.xml.schema.NegativeInteger"+newtype NonNegativeInteger =+  NonNegativeInteger {+    unNonNegativeInteger :: Integer}+  deriving (Eq, Ord, Read, Show)+_NonNegativeInteger = Core.Name "hydra.xml.schema.NonNegativeInteger"+newtype NonPositiveInteger =+  NonPositiveInteger {+    unNonPositiveInteger :: Integer}+  deriving (Eq, Ord, Read, Show)+_NonPositiveInteger = Core.Name "hydra.xml.schema.NonPositiveInteger"+newtype NormalizedString =+  NormalizedString {+    unNormalizedString :: String}+  deriving (Eq, Ord, Read, Show)+_NormalizedString = Core.Name "hydra.xml.schema.NormalizedString"+newtype PositiveInteger =+  PositiveInteger {+    unPositiveInteger :: Integer}+  deriving (Eq, Ord, Read, Show)+_PositiveInteger = Core.Name "hydra.xml.schema.PositiveInteger"+newtype QName =+  QName {+    unQName :: String}+  deriving (Eq, Ord, Read, Show)+_QName = Core.Name "hydra.xml.schema.QName"+newtype Short =+  Short {+    unShort :: I.Int16}+  deriving (Eq, Ord, Read, Show)+_Short = Core.Name "hydra.xml.schema.Short"+newtype String_ =+  String_ {+    unString :: String}+  deriving (Eq, Ord, Read, Show)+_String = Core.Name "hydra.xml.schema.String"+newtype Time =+  Time {+    unTime :: String}+  deriving (Eq, Ord, Read, Show)+_Time = Core.Name "hydra.xml.schema.Time"+newtype Token =+  Token {+    unToken :: String}+  deriving (Eq, Ord, Read, Show)+_Token = Core.Name "hydra.xml.schema.Token"+newtype UnsignedByte =+  UnsignedByte {+    unUnsignedByte :: I.Int16}+  deriving (Eq, Ord, Read, Show)+_UnsignedByte = Core.Name "hydra.xml.schema.UnsignedByte"+newtype UnsignedInt =+  UnsignedInt {+    unUnsignedInt :: I.Int64}+  deriving (Eq, Ord, Read, Show)+_UnsignedInt = Core.Name "hydra.xml.schema.UnsignedInt"+newtype UnsignedLong =+  UnsignedLong {+    unUnsignedLong :: Integer}+  deriving (Eq, Ord, Read, Show)+_UnsignedLong = Core.Name "hydra.xml.schema.UnsignedLong"+newtype UnsignedShort =+  UnsignedShort {+    unUnsignedShort :: Int}+  deriving (Eq, Ord, Read, Show)+_UnsignedShort = Core.Name "hydra.xml.schema.UnsignedShort"+-- | See https://www.w3.org/TR/xmlschema-2/#non-fundamental+newtype ConstrainingFacet =+  ConstrainingFacet {+    unConstrainingFacet :: ()}+  deriving (Eq, Ord, Read, Show)+_ConstrainingFacet = Core.Name "hydra.xml.schema.ConstrainingFacet"+data Datatype =+  DatatypeAnySimpleType |+  DatatypeAnyType |+  DatatypeAnyURI |+  DatatypeBase64Binary |+  DatatypeBoolean |+  DatatypeByte |+  DatatypeDate |+  DatatypeDateTime |+  DatatypeDecimal |+  DatatypeDouble |+  DatatypeDuration |+  DatatypeENTITIES |+  DatatypeENTITY |+  DatatypeFloat |+  DatatypeGDay |+  DatatypeGMonth |+  DatatypeGMonthDay |+  DatatypeGYear |+  DatatypeGYearMonth |+  DatatypeHexBinary |+  DatatypeID |+  DatatypeIDREF |+  DatatypeIDREFS |+  DatatypeInt |+  DatatypeInteger |+  DatatypeLanguage |+  DatatypeLong |+  DatatypeNMTOKEN |+  DatatypeNOTATION |+  DatatypeName |+  DatatypeNegativeInteger |+  DatatypeNonNegativeInteger |+  DatatypeNonPositiveInteger |+  DatatypeNormalizedString |+  DatatypePositiveInteger |+  DatatypeQName |+  DatatypeShort |+  DatatypeString |+  DatatypeTime |+  DatatypeToken |+  DatatypeUnsignedByte |+  DatatypeUnsignedInt |+  DatatypeUnsignedLong |+  DatatypeUnsignedShort+  deriving (Eq, Ord, Read, Show)+_Datatype = Core.Name "hydra.xml.schema.Datatype"+_Datatype_anySimpleType = Core.Name "anySimpleType"+_Datatype_anyType = Core.Name "anyType"+_Datatype_anyURI = Core.Name "anyURI"+_Datatype_base64Binary = Core.Name "base64Binary"+_Datatype_boolean = Core.Name "boolean"+_Datatype_byte = Core.Name "byte"+_Datatype_date = Core.Name "date"+_Datatype_dateTime = Core.Name "dateTime"+_Datatype_decimal = Core.Name "decimal"+_Datatype_double = Core.Name "double"+_Datatype_duration = Core.Name "duration"+_Datatype_ENTITIES = Core.Name "ENTITIES"+_Datatype_ENTITY = Core.Name "ENTITY"+_Datatype_float = Core.Name "float"+_Datatype_gDay = Core.Name "gDay"+_Datatype_gMonth = Core.Name "gMonth"+_Datatype_gMonthDay = Core.Name "gMonthDay"+_Datatype_gYear = Core.Name "gYear"+_Datatype_gYearMonth = Core.Name "gYearMonth"+_Datatype_hexBinary = Core.Name "hexBinary"+_Datatype_ID = Core.Name "ID"+_Datatype_IDREF = Core.Name "IDREF"+_Datatype_IDREFS = Core.Name "IDREFS"+_Datatype_int = Core.Name "int"+_Datatype_integer = Core.Name "integer"+_Datatype_language = Core.Name "language"+_Datatype_long = Core.Name "long"+_Datatype_NMTOKEN = Core.Name "NMTOKEN"+_Datatype_NOTATION = Core.Name "NOTATION"+_Datatype_name = Core.Name "name"+_Datatype_negativeInteger = Core.Name "negativeInteger"+_Datatype_nonNegativeInteger = Core.Name "nonNegativeInteger"+_Datatype_nonPositiveInteger = Core.Name "nonPositiveInteger"+_Datatype_normalizedString = Core.Name "normalizedString"+_Datatype_positiveInteger = Core.Name "positiveInteger"+_Datatype_qName = Core.Name "qName"+_Datatype_short = Core.Name "short"+_Datatype_string = Core.Name "string"+_Datatype_time = Core.Name "time"+_Datatype_token = Core.Name "token"+_Datatype_unsignedByte = Core.Name "unsignedByte"+_Datatype_unsignedInt = Core.Name "unsignedInt"+_Datatype_unsignedLong = Core.Name "unsignedLong"+_Datatype_unsignedShort = Core.Name "unsignedShort"