diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,142 +15,197 @@ --- -## [0.17.1] - unreleased +## [0.17.2] - 2026-07-28 -Development version. Opens the 0.17.x line — the first release built entirely against -published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims -that were needed while 0.16.1 lacked the effect type and I/O primitives removed. +Point release on the 0.17.x line. Themes: promotion of the generator's routing and manifest +logic into Hydra (`hydra.build.*`), per-package API-doc publishing across Java/Scala/Python, +constraint-polymorphic arithmetic, and new effectful stream/file primitives. Includes the base64 +binary-literal rename `literals.binaryToString`/`stringToBinary` → `binaryToBase64`/`base64ToBinary`, +a step toward [#417](https://github.com/CategoricalData/hydra/issues/417) (which remains in progress). +### Highlights + +- **Build system promoted into Hydra**: the three generator drivers now consume `hydra.build.routing` + ([#560](https://github.com/CategoricalData/hydra/issues/560)) and `hydra.build.manifest` + ([#607](https://github.com/CategoricalData/hydra/issues/607)), retiring the legacy static prefix + tables; the cold-seeder oil-and-water violation is fixed + ([#608](https://github.com/CategoricalData/hydra/issues/608)) and guarded + ([#617](https://github.com/CategoricalData/hydra/issues/617)). +- **Per-package API docs** for all doc-bearing hosts: JavaDoc restructured with cross-links and a fixed + tag→CI→Pages chain ([#616](https://github.com/CategoricalData/hydra/issues/616)), plus mirrored + Scaladoc ([#619](https://github.com/CategoricalData/hydra/issues/619)) and Python API docs + ([#620](https://github.com/CategoricalData/hydra/issues/620)). +- **Constraint-polymorphic arithmetic**: a `numeric` type class with enforcement and value-level dispatch + ([#566](https://github.com/CategoricalData/hydra/issues/566)), reflected on the target hosts + ([#618](https://github.com/CategoricalData/hydra/issues/618)). + ### New features +- Standard-stream primitives: `stdin`/`stdout`/`stderr` ([#526](https://github.com/CategoricalData/hydra/issues/526)). +- Recursive flag for `hydra.lib.files.listDirectory` ([#527](https://github.com/CategoricalData/hydra/issues/527)). +- Hydra-specific regex syntax with per-target translation (`hydra.read.regex` / `hydra.show.regex`) + ([#567](https://github.com/CategoricalData/hydra/issues/567)). +- Constraint-polymorphic arithmetic: `numeric` type class + value-level dispatch + ([#566](https://github.com/CategoricalData/hydra/issues/566)). +- Aggregated Java + Scala Maven publishing into a single Central Portal deployment + ([#591](https://github.com/CategoricalData/hydra/issues/591)). + +### Improvements + +- Generator drivers consume `hydra.build.routing` ([#560](https://github.com/CategoricalData/hydra/issues/560)) + and `hydra.build.manifest` ([#607](https://github.com/CategoricalData/hydra/issues/607)). +- Fixed the cold-seeder oil-and-water violation ([#608](https://github.com/CategoricalData/hydra/issues/608)) + and extended `check-oil-and-water.py` to catch cold-seeder imports of unpublished `Hydra.Build.*` + ([#617](https://github.com/CategoricalData/hydra/issues/617)). +- Moved non-kernel packages to strict validation, clearing the #575 backlog + ([#580](https://github.com/CategoricalData/hydra/issues/580)). +- Decoupled `Hydra.Sources.Test.All` from `Hydra.Sources.All`'s re-export list + ([#601](https://github.com/CategoricalData/hydra/issues/601)). +- Renamed `hydra.json.schema` to resolve the module-vs-namespace-prefix conflict that broke + file-per-module hosts ([#532](https://github.com/CategoricalData/hydra/issues/532)). +- Coders route `hydra.lib.*` overlay imports by overlay-module existence, not name-matching + `hydra.lib.defaults` ([#568](https://github.com/CategoricalData/hydra/issues/568)). +- Per-package JavaDoc/Scaladoc/Python-doc publishing + ([#616](https://github.com/CategoricalData/hydra/issues/616), + [#619](https://github.com/CategoricalData/hydra/issues/619), + [#620](https://github.com/CategoricalData/hydra/issues/620)). +- Aligned Java-host Scala/TypeScript generation with Haskell on expression layout (line-wrapping, + declaration order) ([#612](https://github.com/CategoricalData/hydra/issues/612)). + +### Bug fixes + +- **TypeScript** — added the missing CI job (zero prior coverage) + ([#571](https://github.com/CategoricalData/hydra/issues/571)); fixed the + `verify-distribution.sh` smoke-test import so the gate actually gates + ([#578](https://github.com/CategoricalData/hydra/issues/578)); emit `hydra.parse.regex`'s + `regexSequence` before its alternation use (TS2448) + ([#604](https://github.com/CategoricalData/hydra/issues/604)). +- **Build and sync** — `sync.sh` Phase 3 digest-cache now sees cross-package deps on moved kernel + symbols, fixing stale downstream output ([#606](https://github.com/CategoricalData/hydra/issues/606)). +- **Numeric constraints** — `#566` polymorphism now reflected on the target hosts (targets were + monomorphizing `int32->int32->int32`) ([#618](https://github.com/CategoricalData/hydra/issues/618)). + +--- + +## [0.17.1] - 2026-07-18 + +Consolidation release on the 0.17.x line, built against published 0.17.0 hosts. Themes: +generated term-reference DSLs, a translingual package-validation framework, promotion of the +build system into Hydra (`hydra-build`), and broad TypeScript-host and cross-host hardening. + +### Highlights + - **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)): - kernel *term* modules now project generated DSL surfaces, completing the story begun with - type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A - signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated - set of 19 kernel term modules (plus the json/test/extract modules) emits one typed, - rename-safe reference per definition into every target language — e.g. Haskell - `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python - `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto - the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references - and shrinking Python's hand registry to the non-generatable remainder (byte-identical - generated output before and after). Follow-ups: - [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived - encode/decode/show functions via `TypedName`), - [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages). + kernel term modules now emit one typed, rename-safe reference per definition into every target + language; the Java and Python coder sources were pivoted onto them, retiring ~700 stringly-typed + inline references. - **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574), [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*` - framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a - catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574), - definition-name convention (PascalCase), definition ordering, documentation completeness, and - conflicting-variant-name detection — layered on the existing core term/type well-formedness rules. - A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation - backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation) - wiki page for the full per-package constraint specification. -- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)): - fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in - Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered - (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness - scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly - instead of silently vanishing from the generated output. -- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546), - [#529](https://github.com/CategoricalData/hydra/issues/529), - [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had - lived only in host scripts is now translingual Hydra. Pure module-list utilities became - `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530), - each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated - `hydra-build` package (#546), separate from the kernel. -- **Metadata sidecar + content/version-addressed freshness** - ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a - `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the - groundwork for reproducible, cache-correct incremental generation. -- **Structured generation-provenance record** - ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a - structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of - generation metadata. -- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a - principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a - cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question - (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner, - and cross-machine staging coordination. Contributor-facing process only; no change to generated code. + framework with per-package `ValidationProfile`s (undeclared-dependency gate, naming/ordering/docs + checks). See the [Validation](https://github.com/CategoricalData/hydra/wiki/Validation) wiki page. +- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546)): + build-orchestration logic that lived only in host scripts is now translingual Hydra + (`hydra.build.*`), extracted into a dedicated package. -### API and usability +### New features -- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430), - [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python, - and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala - projection helper), bringing the three authoring dialects into closer alignment. +- Generated term-reference DSLs ([#467](https://github.com/CategoricalData/hydra/issues/467)); + follow-ups: `TypedName` refs to derived encode/decode/show + ([#555](https://github.com/CategoricalData/hydra/issues/555)), non-kernel packages + ([#556](https://github.com/CategoricalData/hydra/issues/556)). +- Translingual package-validation framework ([#574](https://github.com/CategoricalData/hydra/issues/574), + [#575](https://github.com/CategoricalData/hydra/issues/575)). +- DSL-authoring registration guards: fail-fast completeness checks for the Java/Python/Scala DSL sources + ([#554](https://github.com/CategoricalData/hydra/issues/554)). +- `hydra-build` package: `hydra.build.modules` + ([#529](https://github.com/CategoricalData/hydra/issues/529)), `hydra.build.reconcile` + ([#530](https://github.com/CategoricalData/hydra/issues/530)), extracted from the kernel + ([#546](https://github.com/CategoricalData/hydra/issues/546)). +- Effectful `hydra.lib.system` primitive library ([#498](https://github.com/CategoricalData/hydra/issues/498)). +- SHA-256 cryptographic hash primitive in `hydra.lib` ([#524](https://github.com/CategoricalData/hydra/issues/524)). +- `hydra-jvm` package: shared JVM serde helpers relocated out of `hydra.java.serde` + ([#505](https://github.com/CategoricalData/hydra/issues/505)). +- Internalized the Hydra-TinkerPop bindings (formerly HydraPop) + ([#442](https://github.com/CategoricalData/hydra/issues/442)). +- Compact unit-valued variants in the JSON encoding ([#520](https://github.com/CategoricalData/hydra/issues/520)). +- Structured generation-provenance record (digest v2) ([#413](https://github.com/CategoricalData/hydra/issues/413), + [#523](https://github.com/CategoricalData/hydra/issues/523)). +- Metadata sidecar + content/version-addressed freshness (`moduleFormatVersion`) + ([#415](https://github.com/CategoricalData/hydra/issues/415)). +- Worker + issue hierarchy: agent/worker framework, cross-worktree messaging, issue-proposal queue + (contributor process only) ([#557](https://github.com/CategoricalData/hydra/issues/557)). -### Fixed +### Improvements -Bug fixes landed this cycle, grouped by area (see each issue for detail): +- Type inference for annotations ([#229](https://github.com/CategoricalData/hydra/issues/229)). +- Fixed the signature / definition split in primitive definitions + ([#502](https://github.com/CategoricalData/hydra/issues/502)). +- DSL usability passes across the host-native Java/Python/Scala surfaces + ([#430](https://github.com/CategoricalData/hydra/issues/430), + [#553](https://github.com/CategoricalData/hydra/issues/553)). +- Audited the Scala and Lisp-family coders for the unconditional `hydra.lib.*` overlay-import rewrite + ([#569](https://github.com/CategoricalData/hydra/issues/569)). -- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling - let bindings and compact bare-string `LiteralType` expansion in the test converter - ([#564](https://github.com/CategoricalData/hydra/issues/564)), - `binaryToBytes` registration + base64 binary decode in `decodeUtf8` - ([#561](https://github.com/CategoricalData/hydra/issues/561)), +### Bug fixes + +- **TypeScript host** — V8 stack budget on ts→Java ([#390](https://github.com/CategoricalData/hydra/issues/390)); + effectful libs not generated / 484 tsc errors ([#503](https://github.com/CategoricalData/hydra/issues/503)); + 15 effect/file inference cases ([#504](https://github.com/CategoricalData/hydra/issues/504)); + ts→ts self-host regression ([#507](https://github.com/CategoricalData/hydra/issues/507)); npm packages + bundling a duplicate kernel ([#584](https://github.com/CategoricalData/hydra/issues/584)); broken npm + entry points ([#587](https://github.com/CategoricalData/hydra/issues/587)); + `hydra.test.build.modules.allTests` gen-universe gap ([#588](https://github.com/CategoricalData/hydra/issues/588)). +- **TypeScript coder** — reactivated `hydra.lib.*` tests: lazy show-calling let bindings + compact + `LiteralType` expansion ([#564](https://github.com/CategoricalData/hydra/issues/564)); `binaryToBytes` + registration + base64 decode in `decodeUtf8` ([#561](https://github.com/CategoricalData/hydra/issues/561)); `hydra.test.build.*` emission after the #546 split - ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in - the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)). -- **Tests and CI** — restored the default-primitive-implementation testing solution - ([#388](https://github.com/CategoricalData/hydra/issues/388), - [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel - test cases ([#513](https://github.com/CategoricalData/hydra/issues/513), - [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI - and split them out of the monolithic Haskell job for timeout headroom - ([#535](https://github.com/CategoricalData/hydra/issues/535), - [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp - self-containment gates to `verify-distribution.sh` - ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check - ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness - fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in - `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a - sync-freshness fingerprint that now sees host-native DSL sources - ([#562](https://github.com/CategoricalData/hydra/issues/562)). + ([#570](https://github.com/CategoricalData/hydra/issues/570)); `HYDRA_DEFAULT_IMPLS` in the test runner + ([#536](https://github.com/CategoricalData/hydra/issues/536)); overlay-import rewrite no longer captures + `hydra.lib.defaults` ([#565](https://github.com/CategoricalData/hydra/issues/565)). +- **Lisp family** — clj→clj bootstrap hang in `generate_source_files` + ([#479](https://github.com/CategoricalData/hydra/issues/479)); Common Lisp `test_graph.lisp` loader + forward-reference ([#496](https://github.com/CategoricalData/hydra/issues/496)); Scheme maps + last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)); Emacs Lisp + bootstrap `wrong-type-argument (listp :string)` ([#586](https://github.com/CategoricalData/hydra/issues/586)); + `hydra.build.*` regeneration into the Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)). - **Kernel and coders** — Java binary-literal signed-byte emission - ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson` - parametric-type (Application/Forall) support - ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in - Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a - kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)). + ([#528](https://github.com/CategoricalData/hydra/issues/528)); `hydra.json.Decode.fromJson` + parametric-type support ([#531](https://github.com/CategoricalData/hydra/issues/531)); stale 2-param + `Coder` shape in Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)); + Java Javadoc ampersand escaping ([#493](https://github.com/CategoricalData/hydra/issues/493)); Scala + coder over-generalizing `Schema[S,T,V,E]` args, breaking `hydra-pg` + ([#589](https://github.com/CategoricalData/hydra/issues/589)); kernel dead-code/TODO cleanup + ([#538](https://github.com/CategoricalData/hydra/issues/538)). +- **Publishing and packaging** — self-broken 0.16.0 `hydra-kernel`/`hydra-python` wheels + ([#472](https://github.com/CategoricalData/hydra/issues/472)). - **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts - ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the - Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps - last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)), - standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)), - the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and - a duplicated generated-file header in `generate-head-haskell-build.py` - ([#540](https://github.com/CategoricalData/hydra/issues/540)). - -- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)): - the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a - generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript. - -- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing - silently since the encoder/decoder modules moved to in-memory synthesis - ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the - failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive - libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are - now included in the lexicon universe, the script fails loudly, and the regenerated - lexicon covers all 267 primitives across 17 library modules. -- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle - subprojects (`:hydra-rdf4j:test` etc.) that were removed in - [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without - checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home - of the former binding tests). -- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still - named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41 - duplicate copies under `dist/haskell/` had become tracked; the rules now match the - `Hydra/Overlay/` location and the duplicates are untracked. + ([#525](https://github.com/CategoricalData/hydra/issues/525)); standalone-kernel SHA dependency + ([#542](https://github.com/CategoricalData/hydra/issues/542)); lexicon's empty Types section + ([#539](https://github.com/CategoricalData/hydra/issues/539)); silent lexicon-generation failure since + the coders moved to in-memory synthesis ([#448](https://github.com/CategoricalData/hydra/issues/448)); + duplicated generated-file header in `generate-head-haskell-build.py` + ([#540](https://github.com/CategoricalData/hydra/issues/540)); `.gitignore` untracking 41 duplicate + overlaid-runtime copies under `dist/haskell/` ([#501](https://github.com/CategoricalData/hydra/issues/501)); + `bin/prepare-release.sh` Java quality check repointed to `dist/java/hydra-pg` tests after + ([#511](https://github.com/CategoricalData/hydra/issues/511)). +- **Tests and CI** — restored default-primitive-implementation testing + ([#388](https://github.com/CategoricalData/hydra/issues/388), + [#549](https://github.com/CategoricalData/hydra/issues/549)); reactivated ignored kernel test cases + ([#513](https://github.com/CategoricalData/hydra/issues/513), + [#550](https://github.com/CategoricalData/hydra/issues/550)); wired + split out the regression harnesses + ([#535](https://github.com/CategoricalData/hydra/issues/535), + [#563](https://github.com/CategoricalData/hydra/issues/563)); Scala/Go/Lisp self-containment gates + ([#537](https://github.com/CategoricalData/hydra/issues/537)); manifest-JSON-tracked CI check + ([#541](https://github.com/CategoricalData/hydra/issues/541)); per-package test-digest freshness + ([#551](https://github.com/CategoricalData/hydra/issues/551)); overlay-file restoration in + `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)); DSL-aware + sync-freshness fingerprint ([#562](https://github.com/CategoricalData/hydra/issues/562)). ### Documentation -- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group - `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`, - [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala - release channels to the README; added TypeScript/Scala/Lisp sections to Getting started; - repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and - PR templates. +- Corrected 0.17.0 Maven coordinates and added npm/Scala release channels, TypeScript/Scala/Lisp + Getting-started sections, and issue/PR templates + ([#519](https://github.com/CategoricalData/hydra/issues/519)). --- diff --git a/hydra-rdf.cabal b/hydra-rdf.cabal --- a/hydra-rdf.cabal +++ b/hydra-rdf.cabal @@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.38.1. +-- 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.1 +version: 0.17.2 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 @@ -45,6 +45,6 @@ build-depends: base >=4.19.0 && <4.22 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.17.1 + , hydra-kernel ==0.17.2 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs b/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs --- a/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs +++ b/src/main/haskell/Hydra/Dsl/Rdf/Syntax.hs @@ -1,7 +1,9 @@ -- 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 @@ -10,18 +12,29 @@ 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 name token for hydra.rdf.syntax.BlankNode +blankNodeBlankNode :: Typed.TypedName Syntax.BlankNode +blankNodeBlankNode = Typed.TypedName (Core.Name "hydra.rdf.syntax.BlankNode") + -- | 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 name token for hydra.rdf.syntax.Dataset +datasetDataset :: Typed.TypedName Syntax.Dataset +datasetDataset = Typed.TypedName (Core.Name "hydra.rdf.syntax.Dataset") + -- | DSL constructor for hydra.rdf.syntax.Description description :: Typed.TypedTerm Syntax.Node -> Typed.TypedTerm Syntax.Graph -> Typed.TypedTerm Syntax.Description description subject graph = @@ -34,6 +47,11 @@ Core.Field { Core.fieldName = (Core.Name "graph"), Core.fieldTerm = (Typed.unTypedTerm graph)}]})) + +-- | DSL name token for hydra.rdf.syntax.Description +descriptionDescription :: Typed.TypedName Syntax.Description +descriptionDescription = Typed.TypedName (Core.Name "hydra.rdf.syntax.Description") + -- | DSL accessor for the graph field of hydra.rdf.syntax.Description descriptionGraph :: Typed.TypedTerm Syntax.Description -> Typed.TypedTerm Syntax.Graph descriptionGraph x = @@ -42,6 +60,7 @@ 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 = @@ -50,6 +69,7 @@ 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 = @@ -66,6 +86,7 @@ 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 = @@ -82,18 +103,29 @@ 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 name token for hydra.rdf.syntax.Graph +graphGraph :: Typed.TypedName Syntax.Graph +graphGraph = Typed.TypedName (Core.Name "hydra.rdf.syntax.Graph") + -- | 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 name token for hydra.rdf.syntax.Iri +iriIri :: Typed.TypedName Syntax.Iri +iriIri = Typed.TypedName (Core.Name "hydra.rdf.syntax.Iri") + -- | DSL injection for the iri variant of hydra.rdf.syntax.IriOrLiteral iriOrLiteralIri :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Syntax.IriOrLiteral iriOrLiteralIri x = @@ -102,6 +134,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "iri"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.rdf.syntax.IriOrLiteral +iriOrLiteralIriOrLiteral :: Typed.TypedName Syntax.IriOrLiteral +iriOrLiteralIriOrLiteral = Typed.TypedName (Core.Name "hydra.rdf.syntax.IriOrLiteral") + -- | DSL injection for the literal variant of hydra.rdf.syntax.IriOrLiteral iriOrLiteralLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.IriOrLiteral iriOrLiteralLiteral x = @@ -110,18 +147,29 @@ 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 name token for hydra.rdf.syntax.LangStrings +langStringsLangStrings :: Typed.TypedName Syntax.LangStrings +langStringsLangStrings = Typed.TypedName (Core.Name "hydra.rdf.syntax.LangStrings") + -- | 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 name token for hydra.rdf.syntax.LanguageTag +languageTagLanguageTag :: Typed.TypedName Syntax.LanguageTag +languageTagLanguageTag = Typed.TypedName (Core.Name "hydra.rdf.syntax.LanguageTag") + -- | 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 = @@ -137,6 +185,7 @@ 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 = @@ -145,6 +194,7 @@ 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 = @@ -153,6 +203,7 @@ 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 = @@ -161,6 +212,11 @@ Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Literal"), Core.projectionFieldName = (Core.Name "lexicalForm")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.rdf.syntax.Literal +literalLiteral :: Typed.TypedName Syntax.Literal +literalLiteral = Typed.TypedName (Core.Name "hydra.rdf.syntax.Literal") + -- | 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 = @@ -184,6 +240,7 @@ 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 = @@ -207,6 +264,7 @@ 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 = @@ -230,6 +288,7 @@ 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 = @@ -238,6 +297,7 @@ 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 = @@ -246,6 +306,7 @@ 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 = @@ -254,6 +315,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "literal"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.rdf.syntax.Node +nodeNode :: Typed.TypedName Syntax.Node +nodeNode = Typed.TypedName (Core.Name "hydra.rdf.syntax.Node") + -- | 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 = @@ -269,6 +335,7 @@ 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 = @@ -277,6 +344,11 @@ Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Property"), Core.projectionFieldName = (Core.Name "domain")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.rdf.syntax.Property +propertyProperty :: Typed.TypedName Syntax.Property +propertyProperty = Typed.TypedName (Core.Name "hydra.rdf.syntax.Property") + -- | DSL accessor for the range field of hydra.rdf.syntax.Property propertyRange :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm (S.Set Syntax.RdfsClass) propertyRange x = @@ -285,6 +357,7 @@ 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 = @@ -293,6 +366,7 @@ 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 = @@ -316,6 +390,7 @@ 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 = @@ -339,6 +414,7 @@ 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 = @@ -362,6 +438,7 @@ 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 = @@ -380,6 +457,7 @@ 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 = @@ -388,6 +466,7 @@ 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 = @@ -396,6 +475,7 @@ 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 = @@ -404,6 +484,11 @@ Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Quad"), Core.projectionFieldName = (Core.Name "predicate")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.rdf.syntax.Quad +quadQuad :: Typed.TypedName Syntax.Quad +quadQuad = Typed.TypedName (Core.Name "hydra.rdf.syntax.Quad") + -- | DSL accessor for the subject field of hydra.rdf.syntax.Quad quadSubject :: Typed.TypedTerm Syntax.Quad -> Typed.TypedTerm Syntax.Resource quadSubject x = @@ -412,6 +497,7 @@ 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 = @@ -442,6 +528,7 @@ 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 = @@ -472,6 +559,7 @@ 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 = @@ -502,6 +590,7 @@ 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 = @@ -532,12 +621,18 @@ 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 name token for hydra.rdf.syntax.RdfsClass +rdfsClassRdfsClass :: Typed.TypedName Syntax.RdfsClass +rdfsClassRdfsClass = Typed.TypedName (Core.Name "hydra.rdf.syntax.RdfsClass") + -- | DSL injection for the bnode variant of hydra.rdf.syntax.Resource resourceBnode :: Typed.TypedTerm Syntax.BlankNode -> Typed.TypedTerm Syntax.Resource resourceBnode x = @@ -546,6 +641,7 @@ 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 = @@ -554,6 +650,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "iri"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.rdf.syntax.Resource +resourceResource :: Typed.TypedName Syntax.Resource +resourceResource = Typed.TypedName (Core.Name "hydra.rdf.syntax.Resource") + -- | 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 = @@ -569,6 +670,7 @@ 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 = @@ -577,6 +679,7 @@ 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 = @@ -585,6 +688,7 @@ 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 = @@ -593,6 +697,11 @@ Core.projectionTypeName = (Core.Name "hydra.rdf.syntax.Triple"), Core.projectionFieldName = (Core.Name "subject")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.rdf.syntax.Triple +tripleTriple :: Typed.TypedName Syntax.Triple +tripleTriple = Typed.TypedName (Core.Name "hydra.rdf.syntax.Triple") + -- | 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 = @@ -616,6 +725,7 @@ 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 = @@ -639,6 +749,7 @@ 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 = @@ -662,42 +773,49 @@ 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 = diff --git a/src/main/haskell/Hydra/Dsl/Shacl/Model.hs b/src/main/haskell/Hydra/Dsl/Shacl/Model.hs --- a/src/main/haskell/Hydra/Dsl/Shacl/Model.hs +++ b/src/main/haskell/Hydra/Dsl/Shacl/Model.hs @@ -1,16 +1,21 @@ -- 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.Errors as Errors +import qualified Hydra.Graph as Graph 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 = @@ -23,6 +28,11 @@ Core.Field { Core.fieldName = (Core.Name "ignoredProperties"), Core.fieldTerm = (Typed.unTypedTerm ignoredProperties)}]})) + +-- | DSL name token for hydra.shacl.model.Closed +closedClosed :: Typed.TypedName Model.Closed +closedClosed = Typed.TypedName (Core.Name "hydra.shacl.model.Closed") + -- | 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 = @@ -31,6 +41,7 @@ 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 = @@ -39,6 +50,7 @@ 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 = @@ -55,6 +67,7 @@ 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 = @@ -71,6 +84,7 @@ 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 = @@ -79,6 +93,7 @@ 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 = @@ -87,6 +102,7 @@ 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 = @@ -95,6 +111,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "closed"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.shacl.model.CommonConstraint +commonConstraintCommonConstraint :: Typed.TypedName Model.CommonConstraint +commonConstraintCommonConstraint = Typed.TypedName (Core.Name "hydra.shacl.model.CommonConstraint") + -- | DSL injection for the datatype variant of hydra.shacl.model.CommonConstraint commonConstraintDatatype :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm Model.CommonConstraint commonConstraintDatatype x = @@ -103,6 +124,7 @@ 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 = @@ -111,6 +133,7 @@ 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 = @@ -119,6 +142,7 @@ 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 = @@ -127,6 +151,7 @@ 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 = @@ -135,6 +160,7 @@ 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 = @@ -143,6 +169,7 @@ 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 = @@ -151,6 +178,7 @@ 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 = @@ -159,6 +187,7 @@ 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 = @@ -167,6 +196,7 @@ 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 = @@ -175,6 +205,7 @@ 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 = @@ -183,6 +214,7 @@ 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 = @@ -191,6 +223,7 @@ 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 = @@ -199,6 +232,7 @@ 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 = @@ -207,6 +241,7 @@ 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 = @@ -215,6 +250,7 @@ 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 = @@ -223,6 +259,7 @@ 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 = @@ -231,6 +268,7 @@ 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 = @@ -239,6 +277,7 @@ 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 = @@ -247,6 +286,7 @@ 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 = @@ -277,6 +317,11 @@ Core.Field { Core.fieldName = (Core.Name "targetSubjectsOf"), Core.fieldTerm = (Typed.unTypedTerm targetSubjectsOf)}]})) + +-- | DSL name token for hydra.shacl.model.CommonProperties +commonPropertiesCommonProperties :: Typed.TypedName Model.CommonProperties +commonPropertiesCommonProperties = Typed.TypedName (Core.Name "hydra.shacl.model.CommonProperties") + -- | DSL accessor for the constraints field of hydra.shacl.model.CommonProperties commonPropertiesConstraints :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm (S.Set Model.CommonConstraint) commonPropertiesConstraints x = @@ -285,6 +330,7 @@ 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 = @@ -293,6 +339,7 @@ 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 = @@ -301,6 +348,7 @@ 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 = @@ -309,6 +357,7 @@ 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 = @@ -317,6 +366,7 @@ 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 = @@ -325,6 +375,7 @@ 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 = @@ -333,6 +384,7 @@ 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 = @@ -341,6 +393,7 @@ 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 = @@ -399,6 +452,7 @@ 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 = @@ -457,6 +511,7 @@ 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 = @@ -515,6 +570,7 @@ 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 = @@ -573,6 +629,7 @@ 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 = @@ -631,6 +688,7 @@ 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 = @@ -689,6 +747,7 @@ 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 = @@ -747,6 +806,7 @@ 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 = @@ -805,6 +865,21 @@ Core.Field { Core.fieldName = (Core.Name "targetSubjectsOf"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL composition builder for the decoder of hydra.shacl.model.Definition +decodeDefinition :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Model.Definition a)) +decodeDefinition a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.shacl.model.definition")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the decoder of hydra.shacl.model.Reference +decodeReference :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Model.Reference a)) +decodeReference a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.shacl.model.reference")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + -- | DSL constructor for hydra.shacl.model.Definition definition :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm a -> Typed.TypedTerm (Model.Definition a) definition iri target = @@ -817,6 +892,11 @@ Core.Field { Core.fieldName = (Core.Name "target"), Core.fieldTerm = (Typed.unTypedTerm target)}]})) + +-- | DSL name token for hydra.shacl.model.Definition +definitionDefinition :: Typed.TypedName (Model.Definition a) +definitionDefinition = Typed.TypedName (Core.Name "hydra.shacl.model.Definition") + -- | DSL accessor for the iri field of hydra.shacl.model.Definition definitionIri :: Typed.TypedTerm (Model.Definition a) -> Typed.TypedTerm Syntax.Iri definitionIri x = @@ -825,6 +905,7 @@ 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 = @@ -833,6 +914,7 @@ 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 = @@ -849,6 +931,7 @@ 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 = @@ -865,6 +948,21 @@ Core.Field { Core.fieldName = (Core.Name "target"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL composition builder for the encoder of hydra.shacl.model.Definition +encodeDefinition :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Model.Definition a -> Core.Term) +encodeDefinition a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.shacl.model.definition")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.shacl.model.Reference +encodeReference :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Model.Reference a -> Core.Term) +encodeReference a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.shacl.model.reference")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + -- | DSL injection for the blankNode variant of hydra.shacl.model.NodeKind nodeKindBlankNode :: Typed.TypedTerm Model.NodeKind nodeKindBlankNode = @@ -873,6 +971,7 @@ 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 = @@ -881,6 +980,7 @@ 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 = @@ -889,6 +989,7 @@ 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 = @@ -897,6 +998,7 @@ 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 = @@ -905,6 +1007,7 @@ 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 = @@ -913,6 +1016,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "literal"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.shacl.model.NodeKind +nodeKindNodeKind :: Typed.TypedName Model.NodeKind +nodeKindNodeKind = Typed.TypedName (Core.Name "hydra.shacl.model.NodeKind") + -- | DSL constructor for hydra.shacl.model.NodeShape nodeShape :: Typed.TypedTerm Model.CommonProperties -> Typed.TypedTerm Model.NodeShape nodeShape common = @@ -922,6 +1030,7 @@ 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 = @@ -930,6 +1039,11 @@ Core.projectionTypeName = (Core.Name "hydra.shacl.model.NodeShape"), Core.projectionFieldName = (Core.Name "common")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.shacl.model.NodeShape +nodeShapeNodeShape :: Typed.TypedName Model.NodeShape +nodeShapeNodeShape = Typed.TypedName (Core.Name "hydra.shacl.model.NodeShape") + -- | 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 = @@ -939,6 +1053,7 @@ 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 = @@ -951,6 +1066,7 @@ 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 = @@ -959,6 +1075,11 @@ Core.projectionTypeName = (Core.Name "hydra.shacl.model.Pattern"), Core.projectionFieldName = (Core.Name "flags")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.shacl.model.Pattern +patternPattern :: Typed.TypedName Model.Pattern +patternPattern = Typed.TypedName (Core.Name "hydra.shacl.model.Pattern") + -- | DSL accessor for the regex field of hydra.shacl.model.Pattern patternRegex :: Typed.TypedTerm Model.Pattern -> Typed.TypedTerm String patternRegex x = @@ -967,6 +1088,7 @@ 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 = @@ -983,6 +1105,7 @@ 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 = @@ -999,6 +1122,7 @@ 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 = @@ -1026,6 +1150,7 @@ 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 = @@ -1034,6 +1159,7 @@ 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 = @@ -1042,6 +1168,7 @@ 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 = @@ -1050,6 +1177,7 @@ 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 = @@ -1058,6 +1186,7 @@ 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 = @@ -1066,6 +1195,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "minCount"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.shacl.model.PropertyShapeConstraint +propertyShapeConstraintPropertyShapeConstraint :: Typed.TypedName Model.PropertyShapeConstraint +propertyShapeConstraintPropertyShapeConstraint = Typed.TypedName (Core.Name "hydra.shacl.model.PropertyShapeConstraint") + -- | DSL injection for the qualifiedValueShape variant of hydra.shacl.model.PropertyShapeConstraint propertyShapeConstraintQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm Model.PropertyShapeConstraint propertyShapeConstraintQualifiedValueShape x = @@ -1074,6 +1208,7 @@ 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 = @@ -1082,6 +1217,7 @@ 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 = @@ -1090,6 +1226,7 @@ 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 = @@ -1098,6 +1235,7 @@ 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 = @@ -1106,6 +1244,7 @@ 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 = @@ -1114,6 +1253,7 @@ 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 = @@ -1122,6 +1262,7 @@ 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 = @@ -1130,6 +1271,11 @@ Core.projectionTypeName = (Core.Name "hydra.shacl.model.PropertyShape"), Core.projectionFieldName = (Core.Name "path")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.shacl.model.PropertyShape +propertyShapePropertyShape :: Typed.TypedName Model.PropertyShape +propertyShapePropertyShape = Typed.TypedName (Core.Name "hydra.shacl.model.PropertyShape") + -- | 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 = @@ -1181,6 +1327,7 @@ 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 = @@ -1232,6 +1379,7 @@ 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 = @@ -1283,6 +1431,7 @@ 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 = @@ -1334,6 +1483,7 @@ 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 = @@ -1385,6 +1535,7 @@ 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 = @@ -1436,6 +1587,7 @@ 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 = @@ -1487,6 +1639,7 @@ 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 = @@ -1505,6 +1658,7 @@ 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 = @@ -1513,6 +1667,7 @@ 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 = @@ -1521,14 +1676,20 @@ Core.projectionTypeName = (Core.Name "hydra.shacl.model.QualifiedValueShape"), Core.projectionFieldName = (Core.Name "qualifiedMinCount")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.shacl.model.QualifiedValueShape +qualifiedValueShapeQualifiedValueShape :: Typed.TypedName Model.QualifiedValueShape +qualifiedValueShapeQualifiedValueShape = Typed.TypedName (Core.Name "hydra.shacl.model.QualifiedValueShape") + -- | DSL accessor for the qualifiedValueShape field of hydra.shacl.model.QualifiedValueShape -qualifiedValueShapeQualifiedValueShape :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape) -qualifiedValueShapeQualifiedValueShape x = +qualifiedValueShapeQualifiedValueShape2 :: Typed.TypedTerm Model.QualifiedValueShape -> Typed.TypedTerm (Model.Reference Model.Shape) +qualifiedValueShapeQualifiedValueShape2 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 = @@ -1537,6 +1698,7 @@ 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 = @@ -1567,6 +1729,7 @@ 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 = @@ -1597,6 +1760,7 @@ 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 = @@ -1627,6 +1791,7 @@ 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 = @@ -1657,6 +1822,7 @@ 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 = @@ -1665,6 +1831,7 @@ 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 = @@ -1673,6 +1840,7 @@ 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 = @@ -1681,6 +1849,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "named"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.shacl.model.Reference +referenceReference :: Typed.TypedName (Model.Reference a) +referenceReference = Typed.TypedName (Core.Name "hydra.shacl.model.Reference") + -- | DSL injection for the info variant of hydra.shacl.model.Severity severityInfo :: Typed.TypedTerm Model.Severity severityInfo = @@ -1689,6 +1862,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "info"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.shacl.model.Severity +severitySeverity :: Typed.TypedName Model.Severity +severitySeverity = Typed.TypedName (Core.Name "hydra.shacl.model.Severity") + -- | DSL injection for the violation variant of hydra.shacl.model.Severity severityViolation :: Typed.TypedTerm Model.Severity severityViolation = @@ -1697,6 +1875,7 @@ 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 = @@ -1705,6 +1884,7 @@ 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 = @@ -1713,6 +1893,7 @@ 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 = @@ -1721,12 +1902,22 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "property"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.shacl.model.Shape +shapeShape :: Typed.TypedName Model.Shape +shapeShape = Typed.TypedName (Core.Name "hydra.shacl.model.Shape") + -- | 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 name token for hydra.shacl.model.ShapesGraph +shapesGraphShapesGraph :: Typed.TypedName Model.ShapesGraph +shapesGraphShapesGraph = Typed.TypedName (Core.Name "hydra.shacl.model.ShapesGraph") + -- | 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 = diff --git a/src/main/haskell/Hydra/Owl/Syntax.hs b/src/main/haskell/Hydra/Owl/Syntax.hs --- a/src/main/haskell/Hydra/Owl/Syntax.hs +++ b/src/main/haskell/Hydra/Owl/Syntax.hs @@ -1,818 +1,1282 @@ -- 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" + +-- | 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 + +-- | An OWL annotation on an axiom, consisting of a property and value +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" + +-- | An OWL annotation assertion axiom +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" + +-- | An OWL annotation axiom +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" + +-- | An OWL annotation property, identified by an IRI +newtype AnnotationProperty = + AnnotationProperty { + unAnnotationProperty :: ()} + deriving (Eq, Ord, Read, Show) + +_AnnotationProperty = Core.Name "hydra.owl.syntax.AnnotationProperty" + +-- | An OWL axiom asserting the domain of an annotation property +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" + +-- | An OWL axiom asserting the range of an annotation property +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" + +-- | An OWL annotation subject: an IRI or an anonymous individual +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" + +-- | An OWL annotation value: an anonymous individual, IRI, or literal +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" + +-- | An OWL anonymous individual, identified by a blank node id +newtype AnonymousIndividual = + AnonymousIndividual { + unAnonymousIndividual :: ()} + deriving (Eq, Ord, Read, Show) + +_AnonymousIndividual = Core.Name "hydra.owl.syntax.AnonymousIndividual" + +-- | An OWL assertion axiom about individuals +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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" + +-- | An OWL axiom +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" + +-- | An OWL class, identified by an IRI +newtype Class = + Class { + unClass :: ()} + deriving (Eq, Ord, Read, Show) + +_Class = Core.Name "hydra.owl.syntax.Class" + +-- | An OWL axiom asserting that an individual belongs to a class +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" + +-- | An OWL axiom about classes +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" + +-- | An OWL class expression +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" + +-- | An OWL universal data property restriction +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" + +-- | An OWL data range which is the complement of another data range +newtype DataComplementOf = + DataComplementOf { + unDataComplementOf :: DataRange} + deriving (Eq, Ord, Read, Show) + +_DataComplementOf = Core.Name "hydra.owl.syntax.DataComplementOf" + +-- | An OWL exact-cardinality restriction on a data property +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" + +-- | An OWL data property restriction requiring a specific literal value +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" + +-- | An OWL data range which is the intersection of two or more data ranges +newtype DataIntersectionOf = + DataIntersectionOf { + unDataIntersectionOf :: [DataRange]} + deriving (Eq, Ord, Read, Show) + +_DataIntersectionOf = Core.Name "hydra.owl.syntax.DataIntersectionOf" + +-- | An OWL maximum-cardinality restriction on a data property +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" + +-- | An OWL minimum-cardinality restriction on a data property +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" + +-- | An OWL data range enumerating one or more literals +newtype DataOneOf = + DataOneOf { + unDataOneOf :: [Syntax.Literal]} + deriving (Eq, Ord, Read, Show) + +_DataOneOf = Core.Name "hydra.owl.syntax.DataOneOf" + +-- | An OWL data property, identified by an IRI +newtype DataProperty = + DataProperty { + unDataProperty :: ()} + deriving (Eq, Ord, Read, Show) + +_DataProperty = Core.Name "hydra.owl.syntax.DataProperty" + +-- | An OWL axiom asserting a data property relationship between an individual and a literal +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" + +-- | An OWL axiom about data properties +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" + +-- | An OWL axiom asserting the domain of a data property +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" + +-- | An OWL data property expression +newtype DataPropertyExpression = + DataPropertyExpression { + unDataPropertyExpression :: DataProperty} + deriving (Eq, Ord, Read, Show) + +_DataPropertyExpression = Core.Name "hydra.owl.syntax.DataPropertyExpression" + +-- | An OWL axiom asserting the range of a data property +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" + +-- | An OWL data range +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" + +-- | An OWL existential data property restriction +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" + +-- | An OWL data range which is the union of two or more data ranges +newtype DataUnionOf = + DataUnionOf { + unDataUnionOf :: [DataRange]} + deriving (Eq, Ord, Read, Show) + +_DataUnionOf = Core.Name "hydra.owl.syntax.DataUnionOf" + +-- | An OWL datatype, identified by an IRI +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" + +-- | An OWL axiom defining a datatype in terms of a data range +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" + +-- | An OWL datatype restricted by one or more constraining facets +data DatatypeRestriction = + DatatypeRestriction { + datatypeRestrictionDatatype :: Datatype, + datatypeRestrictionConstraints :: [DatatypeRestrictionConstraint]} + deriving (Eq, Ord, Read, Show) + +_DatatypeRestriction = Core.Name "hydra.owl.syntax.DatatypeRestriction" + +_DatatypeRestriction_datatype = Core.Name "datatype" + +_DatatypeRestriction_constraints = Core.Name "constraints" + +-- | A constraining facet used in an OWL datatype restriction +data DatatypeRestrictionConstrainingFacet = + -- | 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 + DatatypeRestrictionConstrainingFacetXmlSchema Schema.ConstrainingFacet | + DatatypeRestrictionConstrainingFacetOther Syntax.Iri + deriving (Eq, Ord, Read, Show) + +_DatatypeRestrictionConstrainingFacet = Core.Name "hydra.owl.syntax.DatatypeRestrictionConstrainingFacet" + +_DatatypeRestrictionConstrainingFacet_xmlSchema = Core.Name "xmlSchema" + +_DatatypeRestrictionConstrainingFacet_other = Core.Name "other" + +-- | A single constraining facet and its restriction value in an OWL datatype restriction +data DatatypeRestrictionConstraint = + DatatypeRestrictionConstraint { + datatypeRestrictionConstraintConstrainingFacet :: DatatypeRestrictionConstrainingFacet, + datatypeRestrictionConstraintRestrictionValue :: Syntax.Literal} + deriving (Eq, Ord, Read, Show) + +_DatatypeRestrictionConstraint = Core.Name "hydra.owl.syntax.DatatypeRestrictionConstraint" + +_DatatypeRestrictionConstraint_constrainingFacet = Core.Name "constrainingFacet" + +_DatatypeRestrictionConstraint_restrictionValue = Core.Name "restrictionValue" + +-- | An OWL entity declaration +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" + +-- | An OWL axiom asserting that two or more individuals are pairwise distinct +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" + +-- | An OWL axiom asserting that two or more classes are pairwise disjoint +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" + +-- | An OWL axiom asserting that two or more data properties are pairwise disjoint +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" + +-- | An OWL axiom asserting that two or more object properties are pairwise disjoint +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" + +-- | An OWL axiom asserting that a class is the disjoint union of other 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" + +-- | An OWL entity: a class, datatype, object/data/annotation property, or named individual +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" + +-- | An OWL axiom asserting that two or more classes are equivalent +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" + +-- | An OWL axiom asserting that two or more data properties are equivalent +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" + +-- | An OWL axiom asserting that two or more object properties are equivalent +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" + +-- | An OWL axiom asserting that a data property is functional +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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property +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" + +-- | An OWL axiom asserting that a set of properties functions as a key for a class +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" + +-- | An OWL individual: a named individual or an anonymous individual +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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" + +-- | An OWL axiom asserting that two object properties are inverses of each other +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" + +-- | The inverse of an OWL object property +newtype InverseObjectProperty = + InverseObjectProperty { + unInverseObjectProperty :: ObjectProperty} + deriving (Eq, Ord, Read, Show) + +_InverseObjectProperty = Core.Name "hydra.owl.syntax.InverseObjectProperty" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" + +-- | An OWL named individual, identified by an IRI +newtype NamedIndividual = + NamedIndividual { + unNamedIndividual :: ()} + deriving (Eq, Ord, Read, Show) + +_NamedIndividual = Core.Name "hydra.owl.syntax.NamedIndividual" + +-- | An OWL axiom asserting that a data property relationship does NOT hold +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" + +-- | An OWL axiom asserting that an object property relationship does NOT hold +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" + +-- | An OWL universal object property restriction +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" + +-- | An OWL class expression which is the complement of another class expression +newtype ObjectComplementOf = + ObjectComplementOf { + unObjectComplementOf :: ClassExpression} + deriving (Eq, Ord, Read, Show) + +_ObjectComplementOf = Core.Name "hydra.owl.syntax.ObjectComplementOf" + +-- | An OWL exact-cardinality restriction on an object property +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" + +-- | An OWL class expression restricting an object property to self-relationships +newtype ObjectHasSelf = + ObjectHasSelf { + unObjectHasSelf :: ObjectPropertyExpression} + deriving (Eq, Ord, Read, Show) + +_ObjectHasSelf = Core.Name "hydra.owl.syntax.ObjectHasSelf" + +-- | An OWL object property restriction requiring a specific individual value +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" + +-- | An OWL class expression which is the intersection of two or more class expressions +newtype ObjectIntersectionOf = + ObjectIntersectionOf { + unObjectIntersectionOf :: [ClassExpression]} + deriving (Eq, Ord, Read, Show) + +_ObjectIntersectionOf = Core.Name "hydra.owl.syntax.ObjectIntersectionOf" + +-- | An OWL maximum-cardinality restriction on an object property +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" + +-- | An OWL minimum-cardinality restriction on an object property +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" + +-- | An OWL class expression enumerating one or more individuals +newtype ObjectOneOf = + ObjectOneOf { + unObjectOneOf :: [Individual]} + deriving (Eq, Ord, Read, Show) + +_ObjectOneOf = Core.Name "hydra.owl.syntax.ObjectOneOf" + +-- | An OWL object property, identified by an IRI +newtype ObjectProperty = + ObjectProperty { + unObjectProperty :: ()} + deriving (Eq, Ord, Read, Show) + +_ObjectProperty = Core.Name "hydra.owl.syntax.ObjectProperty" + +-- | An OWL axiom asserting an object property relationship between two individuals +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" + +-- | An OWL axiom about object properties +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" + +-- | An OWL axiom asserting the domain of an object property +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" + +-- | An OWL object property expression: an object property or its inverse +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" + +-- | An OWL axiom asserting the range of an object property +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" + +-- | An OWL existential object property restriction +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" + +-- | An OWL class expression which is the union of two or more class expressions +newtype ObjectUnionOf = + ObjectUnionOf { + unObjectUnionOf :: [ClassExpression]} + deriving (Eq, Ord, Read, Show) + +_ObjectUnionOf = Core.Name "hydra.owl.syntax.ObjectUnionOf" + +-- | An OWL ontology: a set of imports, annotations, and axioms +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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" + +-- | An OWL axiom asserting that two or more individuals are the same +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" + +-- | An OWL axiom asserting an annotation-property subsumption relationship +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" + +-- | An OWL axiom asserting a subclass relationship +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" + +-- | An OWL axiom asserting a data-property subsumption relationship +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" + +-- | An OWL axiom asserting an object-property subsumption relationship +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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" + +-- | An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object 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" diff --git a/src/main/haskell/Hydra/Rdf/Serde.hs b/src/main/haskell/Hydra/Rdf/Serde.hs --- a/src/main/haskell/Hydra/Rdf/Serde.hs +++ b/src/main/haskell/Hydra/Rdf/Serde.hs @@ -1,14 +1,20 @@ -- 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.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality @@ -23,10 +29,13 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Rdf.Syntax as Syntax +import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -35,34 +44,42 @@ 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 = @@ -70,12 +87,14 @@ 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 = @@ -95,6 +114,7 @@ in (Serialization.noSep [ lexExpr, suffix]) + -- | Convert a node to an expression nodeToExpr :: Syntax.Node -> Ast.Expr nodeToExpr n = @@ -102,15 +122,18 @@ 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 = @@ -123,6 +146,7 @@ (iriToExpr pred), (nodeToExpr obj), (Serialization.cst ".")]) + -- | Format a code point as a 4-digit UCHAR escape sequence uchar4 :: Int -> String uchar4 c = diff --git a/src/main/haskell/Hydra/Rdf/Syntax.hs b/src/main/haskell/Hydra/Rdf/Syntax.hs --- a/src/main/haskell/Hydra/Rdf/Syntax.hs +++ b/src/main/haskell/Hydra/Rdf/Syntax.hs @@ -1,68 +1,88 @@ -- 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 + +-- | An RDF blank node identifier 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" + +-- | A set of RDF quads 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" + +-- | A set of RDF triples 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 { @@ -73,19 +93,30 @@ -- | 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" + +-- | An RDF node: an IRI, a blank node, or a literal 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 { @@ -95,10 +126,15 @@ 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 { @@ -107,18 +143,37 @@ 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" + +-- | Stand-in for rdfs:Class +newtype RdfsClass = + RdfsClass { + unRdfsClass :: ()} + deriving (Eq, Ord, Read, Show) + +_RdfsClass = Core.Name "hydra.rdf.syntax.RdfsClass" + +-- | An RDF resource: an IRI or a blank node 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 { @@ -126,7 +181,11 @@ 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" diff --git a/src/main/haskell/Hydra/Rdf/Utils.hs b/src/main/haskell/Hydra/Rdf/Utils.hs --- a/src/main/haskell/Hydra/Rdf/Utils.hs +++ b/src/main/haskell/Hydra/Rdf/Utils.hs @@ -1,14 +1,20 @@ -- 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.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model @@ -26,9 +32,12 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Rdf.Syntax as Syntax +import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -37,21 +46,26 @@ 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 = @@ -114,6 +128,7 @@ 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 = @@ -121,22 +136,28 @@ 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 = @@ -150,21 +171,26 @@ "#", (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 diff --git a/src/main/haskell/Hydra/Shacl/Coder.hs b/src/main/haskell/Hydra/Shacl/Coder.hs --- a/src/main/haskell/Hydra/Shacl/Coder.hs +++ b/src/main/haskell/Hydra/Shacl/Coder.hs @@ -1,19 +1,25 @@ -- 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.Docs as Docs 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.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as JsonModel @@ -35,11 +41,14 @@ import qualified Hydra.Query as Query import qualified Hydra.Rdf.Syntax as Syntax import qualified Hydra.Rdf.Utils as Utils +import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Shacl.Model as ShaclModel import qualified Hydra.Strip as Strip +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -48,6 +57,7 @@ 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 = @@ -60,12 +70,15 @@ 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 = @@ -79,6 +92,7 @@ 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 = @@ -109,6 +123,7 @@ 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 = @@ -138,6 +153,7 @@ 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 = @@ -161,6 +177,7 @@ 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 = @@ -216,6 +233,7 @@ 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 = @@ -240,17 +258,21 @@ 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 = @@ -262,6 +284,7 @@ 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 = @@ -289,6 +312,7 @@ 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 = @@ -297,6 +321,7 @@ expected, ", found: ", found]) + -- | Add an rdf:type triple to an RDF Description withType :: Core.Name -> Syntax.Description -> Syntax.Description withType name desc = diff --git a/src/main/haskell/Hydra/Shacl/Language.hs b/src/main/haskell/Hydra/Shacl/Language.hs --- a/src/main/haskell/Hydra/Shacl/Language.hs +++ b/src/main/haskell/Hydra/Shacl/Language.hs @@ -1,14 +1,20 @@ -- 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.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model import qualified Hydra.Lexical as Lexical @@ -17,9 +23,12 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query +import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -28,6 +37,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | Language constraints for W3C SHACL shaclLanguage :: Coders.Language shaclLanguage = @@ -39,7 +49,23 @@ Coders.languageConstraintsIntegerTypes = integerTypes, Coders.languageConstraintsTermVariants = termVariants, Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}} + Coders.languageConstraintsTypes = typePredicate}, + Coders.languageSupportedFeatures = (Sets.fromList [ + Coders.LanguageFeaturePartialApplication, + Coders.LanguageFeatureNestedCaseStatements, + Coders.LanguageFeatureNestedPolymorphicLetBindings]), + Coders.languageCaseConventions = Coders.CaseConventions { + Coders.caseConventionsConstant = Util.CaseConventionUpperSnake, + Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake, + Coders.caseConventionsEnumValue = Util.CaseConventionPascal, + Coders.caseConventionsField = Util.CaseConventionCamel, + Coders.caseConventionsFile = Util.CaseConventionLowerSnake, + Coders.caseConventionsModule = Util.CaseConventionLowerSnake, + Coders.caseConventionsTerm = Util.CaseConventionCamel, + Coders.caseConventionsTermVariable = Util.CaseConventionCamel, + Coders.caseConventionsType = Util.CaseConventionPascal, + Coders.caseConventionsTypeVariable = Util.CaseConventionPascal}, + Coders.languageDefaultFileExtension = (File.FileExtension "ttl")} where literalVariants = Sets.fromList [ diff --git a/src/main/haskell/Hydra/Shacl/Model.hs b/src/main/haskell/Hydra/Shacl/Model.hs --- a/src/main/haskell/Hydra/Shacl/Model.hs +++ b/src/main/haskell/Hydra/Shacl/Model.hs @@ -1,21 +1,28 @@ -- 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 + +-- | A SHACL closed-shape constraint, restricting a node's properties to those explicitly listed or ignored 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 @@ -63,29 +70,53 @@ -- | 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 { @@ -106,24 +137,39 @@ -- | 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" + +-- | The SHACL node kind of an RDF term data NodeKind = -- | A blank node NodeKindBlankNode | @@ -138,29 +184,44 @@ -- | 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 { @@ -177,14 +238,23 @@ 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 @@ -200,14 +270,22 @@ -- | 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 + +-- | A SHACL qualified value shape constraint, requiring a count of values conforming to a given shape data QualifiedValueShape = QualifiedValueShape { qualifiedValueShapeQualifiedValueShape :: (Reference Shape), @@ -215,11 +293,17 @@ 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 | @@ -228,10 +312,16 @@ -- | 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" + +-- | The severity of a SHACL constraint violation data Severity = -- | A non-critical constraint violation indicating an informative message SeverityInfo | @@ -240,21 +330,31 @@ -- | 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" diff --git a/src/main/haskell/Hydra/Shex/Syntax.hs b/src/main/haskell/Hydra/Shex/Syntax.hs --- a/src/main/haskell/Hydra/Shex/Syntax.hs +++ b/src/main/haskell/Hydra/Shex/Syntax.hs @@ -1,1068 +1,1745 @@ -- 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" + +-- | 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 + +-- | ShEx grammar production: Annotation ::= '//' Predicate (Iri | Literal) +data Annotation = + Annotation { + annotationPredicate :: Predicate, + annotationAlts :: AnnotationAlts} + deriving (Eq, Ord, Read, Show) + +_Annotation = Core.Name "hydra.shex.syntax.Annotation" + +_Annotation_Predicate = Core.Name "Predicate" + +_Annotation_alts = Core.Name "alts" + +-- | A synthetic Hydra type representing the alternatives of the ShEx Annotation production +data AnnotationAlts = + AnnotationAltsIri Iri | + AnnotationAltsLiteral Literal + deriving (Eq, Ord, Read, Show) + +_AnnotationAlts = Core.Name "hydra.shex.syntax.AnnotationAlts" + +_AnnotationAlts_Iri = Core.Name "Iri" + +_AnnotationAlts_Literal = Core.Name "Literal" + +-- | ShEx grammar production: AtpNameLn ::= '@' PnameNs PnLocal +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" + +-- | ShEx grammar production: AtpNameNs ::= '@' PnPrefix? ':' +newtype AtpNameNs = + AtpNameNs { + unAtpNameNs :: (Maybe PnPrefix)} + deriving (Eq, Ord, Read, Show) + +_AtpNameNs = Core.Name "hydra.shex.syntax.AtpNameNs" + +-- | ShEx grammar production: BaseDecl ::= 'BASE' IriRef +newtype BaseDecl = + BaseDecl { + unBaseDecl :: IriRef} + deriving (Eq, Ord, Read, Show) + +_BaseDecl = Core.Name "hydra.shex.syntax.BaseDecl" + +-- | ShEx grammar production: BlankNode ::= BlankNodeLabel +newtype BlankNode = + BlankNode { + unBlankNode :: BlankNodeLabel} + deriving (Eq, Ord, Read, Show) + +_BlankNode = Core.Name "hydra.shex.syntax.BlankNode" + +-- | A component of the ShEx BlankNodeLabel production +data BlankNodeLabel = + BlankNodeLabel { + blankNodeLabelAlts :: BlankNodeLabelAlts, + blankNodeLabelListOfAlts :: (Maybe [BlankNodeLabelListOfAltsOptionElmt]), + 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" + +-- | A synthetic Hydra type representing the alternatives of the ShEx BlankNodeLabel production +data BlankNodeLabelAlts = + BlankNodeLabelAltsPnCharsU PnCharsU | + BlankNodeLabelAltsRegex String + deriving (Eq, Ord, Read, Show) + +_BlankNodeLabelAlts = Core.Name "hydra.shex.syntax.BlankNodeLabelAlts" + +_BlankNodeLabelAlts_PnCharsU = Core.Name "PnCharsU" + +_BlankNodeLabelAlts_regex = Core.Name "regex" + +-- | A synthetic Hydra type representing one alternative of an optional list element within the ShEx BlankNodeLabel production +data BlankNodeLabelListOfAltsOptionElmt = + BlankNodeLabelListOfAltsOptionElmtPnChars PnChars | + BlankNodeLabelListOfAltsOptionElmtPeriod + deriving (Eq, Ord, Read, Show) + +_BlankNodeLabelListOfAltsOptionElmt = Core.Name "hydra.shex.syntax.BlankNodeLabelListOfAltsOptionElmt" + +_BlankNodeLabelListOfAltsOptionElmt_PnChars = Core.Name "PnChars" + +_BlankNodeLabelListOfAltsOptionElmt_Period = Core.Name "Period" + +-- | ShEx grammar production: BooleanLiteral ::= 'true' | 'false' +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" + +-- | A component of the ShEx BracketedTripleExpr production +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" + +-- | ShEx grammar production: Cardinality ::= '*' | '+' | '?' | RepeatRange +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" + +-- | A component of the ShEx Code production +newtype Code = + Code { + unCode :: [CodeElmt]} + deriving (Eq, Ord, Read, Show) + +_Code = Core.Name "hydra.shex.syntax.Code" + +-- | ShEx grammar production: CodeDecl ::= '%' Iri (Code | '%') +data CodeDecl = + CodeDecl { + codeDeclIri :: Iri, + codeDeclAlts :: CodeDeclAlts} + deriving (Eq, Ord, Read, Show) + +_CodeDecl = Core.Name "hydra.shex.syntax.CodeDecl" + +_CodeDecl_Iri = Core.Name "Iri" + +_CodeDecl_alts = Core.Name "alts" + +-- | A synthetic Hydra type representing the alternatives of the ShEx CodeDecl production +data CodeDeclAlts = + CodeDeclAltsCode Code | + CodeDeclAltsPercnt + deriving (Eq, Ord, Read, Show) + +_CodeDeclAlts = Core.Name "hydra.shex.syntax.CodeDeclAlts" + +_CodeDeclAlts_Code = Core.Name "Code" + +_CodeDeclAlts_Percnt = Core.Name "Percnt" + +-- | A synthetic Hydra type representing one element of the ShEx Code production +data CodeElmt = + CodeElmtRegex String | + CodeElmtSequence String | + CodeElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_CodeElmt = Core.Name "hydra.shex.syntax.CodeElmt" + +_CodeElmt_regex = Core.Name "regex" + +_CodeElmt_sequence = Core.Name "sequence" + +_CodeElmt_Uchar = Core.Name "Uchar" + +-- | ShEx grammar production: Datatype ::= Iri +newtype Datatype = + Datatype { + unDatatype :: Iri} + deriving (Eq, Ord, Read, Show) + +_Datatype = Core.Name "hydra.shex.syntax.Datatype" + +-- | A component of the ShEx Decimal production +newtype Decimal = + Decimal { + unDecimal :: String} + deriving (Eq, Ord, Read, Show) + +_Decimal = Core.Name "hydra.shex.syntax.Decimal" + +-- | ShEx grammar production: Directive ::= BaseDecl | PrefixDecl +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" + +-- | A component of the ShEx Double production +newtype Double_ = + Double_ { + unDouble :: String} + deriving (Eq, Ord, Read, Show) + +_Double = Core.Name "hydra.shex.syntax.Double" + +-- | ShEx grammar production: Echar ::= '\' [tbnrf\''] +newtype Echar = + Echar { + unEchar :: String} + deriving (Eq, Ord, Read, Show) + +_Echar = Core.Name "hydra.shex.syntax.Echar" + +-- | ShEx grammar production: Exclusion ::= '-' Iri '~'? +newtype Exclusion = + Exclusion { + unExclusion :: Iri} + deriving (Eq, Ord, Read, Show) + +_Exclusion = Core.Name "hydra.shex.syntax.Exclusion" + +-- | ShEx grammar production: ExtraPropertySet ::= 'EXTRA' Predicate+ +newtype ExtraPropertySet = + ExtraPropertySet { + unExtraPropertySet :: [Predicate]} + deriving (Eq, Ord, Read, Show) + +_ExtraPropertySet = Core.Name "hydra.shex.syntax.ExtraPropertySet" + +-- | ShEx grammar production: GroupTripleExpr ::= SingleElementGroup | MultiElementGroup +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" + +-- | ShEx grammar production: Hex ::= [0-9] | [A-F] | [a-f] +newtype Hex = + Hex { + unHex :: String} + deriving (Eq, Ord, Read, Show) + +_Hex = Core.Name "hydra.shex.syntax.Hex" + +-- | ShEx grammar production: Include ::= '&' TripleExprLabel +newtype Include = + Include { + unInclude :: TripleExprLabel} + deriving (Eq, Ord, Read, Show) + +_Include = Core.Name "hydra.shex.syntax.Include" + +-- | ShEx grammar production: IncludeSet ::= '&' ShapeExprLabel+ +newtype IncludeSet = + IncludeSet { + unIncludeSet :: [ShapeExprLabel]} + deriving (Eq, Ord, Read, Show) + +_IncludeSet = Core.Name "hydra.shex.syntax.IncludeSet" + +-- | ShEx grammar production: InlineShapeAnd ::= InlineShapeNot ('AND' InlineShapeNot)* +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" + +-- | A component of the ShEx InlineShapeAtom production +data InlineShapeAtom = + InlineShapeAtomSeq InlineShapeAtomSequence | + InlineShapeAtomSeq2 InlineShapeAtomSequence2 | + InlineShapeAtomSequence3 ShapeExpression | + InlineShapeAtomPeriod + deriving (Eq, Ord, Read, Show) + +_InlineShapeAtom = Core.Name "hydra.shex.syntax.InlineShapeAtom" + +_InlineShapeAtom_seq = Core.Name "seq" + +_InlineShapeAtom_seq2 = Core.Name "seq2" + +_InlineShapeAtom_sequence3 = Core.Name "sequence3" + +_InlineShapeAtom_Period = Core.Name "Period" + +-- | A synthetic Hydra type representing a sequence within the ShEx InlineShapeAtom production +data InlineShapeAtomSequence = + InlineShapeAtomSequence { + inlineShapeAtomSequenceNodeConstraint :: NodeConstraint, + inlineShapeAtomSequenceInlineShapeOrRef :: (Maybe InlineShapeOrRef)} + deriving (Eq, Ord, Read, Show) + +_InlineShapeAtomSequence = Core.Name "hydra.shex.syntax.InlineShapeAtomSequence" + +_InlineShapeAtomSequence_NodeConstraint = Core.Name "NodeConstraint" + +_InlineShapeAtomSequence_InlineShapeOrRef = Core.Name "InlineShapeOrRef" + +-- | A synthetic Hydra type representing a secondary sequence within the ShEx InlineShapeAtom production +data InlineShapeAtomSequence2 = + InlineShapeAtomSequence2 { + inlineShapeAtomSequence2InlineShapeOrRef :: InlineShapeOrRef, + inlineShapeAtomSequence2NodeConstraint :: (Maybe NodeConstraint)} + deriving (Eq, Ord, Read, Show) + +_InlineShapeAtomSequence2 = Core.Name "hydra.shex.syntax.InlineShapeAtomSequence2" + +_InlineShapeAtomSequence2_InlineShapeOrRef = Core.Name "InlineShapeOrRef" + +_InlineShapeAtomSequence2_NodeConstraint = Core.Name "NodeConstraint" + +-- | A component of the ShEx InlineShapeDefinition production +data InlineShapeDefinition = + InlineShapeDefinition { + inlineShapeDefinitionListOfAlts :: [InlineShapeDefinitionListOfAltsElmt], + 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" + +-- | A synthetic Hydra type representing one element of the ShEx InlineShapeDefinitionListOfAlts production +data InlineShapeDefinitionListOfAltsElmt = + InlineShapeDefinitionListOfAltsElmtIncludeSet IncludeSet | + InlineShapeDefinitionListOfAltsElmtExtraPropertySet ExtraPropertySet | + InlineShapeDefinitionListOfAltsElmtCLOSED + deriving (Eq, Ord, Read, Show) + +_InlineShapeDefinitionListOfAltsElmt = Core.Name "hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmt" + +_InlineShapeDefinitionListOfAltsElmt_IncludeSet = Core.Name "IncludeSet" + +_InlineShapeDefinitionListOfAltsElmt_ExtraPropertySet = Core.Name "ExtraPropertySet" + +_InlineShapeDefinitionListOfAltsElmt_CLOSED = Core.Name "CLOSED" + +-- | ShEx grammar production: InlineShapeExpression ::= InlineShapeOr +newtype InlineShapeExpression = + InlineShapeExpression { + unInlineShapeExpression :: InlineShapeOr} + deriving (Eq, Ord, Read, Show) + +_InlineShapeExpression = Core.Name "hydra.shex.syntax.InlineShapeExpression" + +-- | ShEx grammar production: InlineShapeNot ::= 'NOT'? InlineShapeAtom +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" + +-- | ShEx grammar production: InlineShapeOr ::= InlineShapeAnd ('OR' InlineShapeAnd)* +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" + +-- | A component of the ShEx InlineShapeOrRef production +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" + +-- | ShEx grammar production: InnerTripleExpr ::= MultiElementGroup | MultiElementOneOf +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" + +-- | A component of the ShEx Integer production +newtype Integer_ = + Integer_ { + unInteger :: String} + deriving (Eq, Ord, Read, Show) + +_Integer = Core.Name "hydra.shex.syntax.Integer" + +-- | ShEx grammar production: Iri ::= IriRef | PrefixedName +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" + +-- | A component of the ShEx IriRange production +data IriRange = + IriRangeSeq IriRangeSequence | + IriRangeSequence2 [Exclusion] + deriving (Eq, Ord, Read, Show) + +_IriRange = Core.Name "hydra.shex.syntax.IriRange" + +_IriRange_seq = Core.Name "seq" + +_IriRange_sequence2 = Core.Name "sequence2" + +-- | A synthetic Hydra type representing a sequence within the ShEx IriRange production +data IriRangeSequence = + IriRangeSequence { + iriRangeSequenceIri :: Iri, + iriRangeSequenceSequence :: (Maybe [Exclusion])} + deriving (Eq, Ord, Read, Show) + +_IriRangeSequence = Core.Name "hydra.shex.syntax.IriRangeSequence" + +_IriRangeSequence_Iri = Core.Name "Iri" + +_IriRangeSequence_Sequence = Core.Name "Sequence" + +-- | A component of the ShEx IriRef production +newtype IriRef = + IriRef { + unIriRef :: [IriRefElmt]} + deriving (Eq, Ord, Read, Show) + +_IriRef = Core.Name "hydra.shex.syntax.IriRef" + +-- | A synthetic Hydra type representing one element of the ShEx IriRef production +data IriRefElmt = + IriRefElmtRegex String | + IriRefElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_IriRefElmt = Core.Name "hydra.shex.syntax.IriRefElmt" + +_IriRefElmt_regex = Core.Name "regex" + +_IriRefElmt_Uchar = Core.Name "Uchar" + +-- | A component of the ShEx LangTag production +newtype LangTag = + LangTag { + unLangTag :: String} + deriving (Eq, Ord, Read, Show) + +_LangTag = Core.Name "hydra.shex.syntax.LangTag" + +-- | ShEx grammar production: Literal ::= RdfLiteral | NumericLiteral | BooleanLiteral +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" + +-- | ShEx grammar production: MultiElementGroup ::= UnaryTripleExpr (';' UnaryTripleExpr)+ ';'? +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" + +-- | ShEx grammar production: MultiElementOneOf ::= GroupTripleExpr ('|' GroupTripleExpr)+ +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" + +-- | A component of the ShEx NodeConstraint production +data NodeConstraint = + NodeConstraintSequence [XsFacet] | + NodeConstraintSeq2 NodeConstraintSequence2 | + NodeConstraintSeq3 NodeConstraintSequence3 | + NodeConstraintSeq4 NodeConstraintSequence4 | + NodeConstraintSeq5 NodeConstraintSequence5 | + NodeConstraintListOfXsFacet [XsFacet] + deriving (Eq, Ord, Read, Show) + +_NodeConstraint = Core.Name "hydra.shex.syntax.NodeConstraint" + +_NodeConstraint_sequence = Core.Name "sequence" + +_NodeConstraint_seq2 = Core.Name "seq2" + +_NodeConstraint_seq3 = Core.Name "seq3" + +_NodeConstraint_seq4 = Core.Name "seq4" + +_NodeConstraint_seq5 = Core.Name "seq5" + +_NodeConstraint_listOfXsFacet = Core.Name "listOfXsFacet" + +-- | A synthetic Hydra type representing a secondary sequence within the ShEx NodeConstraint production +data NodeConstraintSequence2 = + NodeConstraintSequence2 { + nodeConstraintSequence2NonLiteralKind :: NonLiteralKind, + nodeConstraintSequence2ListOfStringFacet :: [StringFacet]} + deriving (Eq, Ord, Read, Show) + +_NodeConstraintSequence2 = Core.Name "hydra.shex.syntax.NodeConstraintSequence2" + +_NodeConstraintSequence2_NonLiteralKind = Core.Name "NonLiteralKind" + +_NodeConstraintSequence2_listOfStringFacet = Core.Name "listOfStringFacet" + +-- | A synthetic Hydra type representing a tertiary sequence within the ShEx NodeConstraint production +data NodeConstraintSequence3 = + NodeConstraintSequence3 { + nodeConstraintSequence3Datatype :: Datatype, + nodeConstraintSequence3ListOfXsFacet :: [XsFacet]} + deriving (Eq, Ord, Read, Show) + +_NodeConstraintSequence3 = Core.Name "hydra.shex.syntax.NodeConstraintSequence3" + +_NodeConstraintSequence3_Datatype = Core.Name "Datatype" + +_NodeConstraintSequence3_listOfXsFacet = Core.Name "listOfXsFacet" + +-- | A synthetic Hydra type representing a quaternary sequence within the ShEx NodeConstraint production +data NodeConstraintSequence4 = + NodeConstraintSequence4 { + nodeConstraintSequence4ValueSet :: ValueSet, + nodeConstraintSequence4ListOfXsFacet :: [XsFacet]} + deriving (Eq, Ord, Read, Show) + +_NodeConstraintSequence4 = Core.Name "hydra.shex.syntax.NodeConstraintSequence4" + +_NodeConstraintSequence4_ValueSet = Core.Name "ValueSet" + +_NodeConstraintSequence4_listOfXsFacet = Core.Name "listOfXsFacet" + +-- | A synthetic Hydra type representing a quinary sequence within the ShEx NodeConstraint production +data NodeConstraintSequence5 = + NodeConstraintSequence5 { + nodeConstraintSequence5ValueSet :: ValueSet, + nodeConstraintSequence5ListOfXsFacet :: [XsFacet]} + deriving (Eq, Ord, Read, Show) + +_NodeConstraintSequence5 = Core.Name "hydra.shex.syntax.NodeConstraintSequence5" + +_NodeConstraintSequence5_ValueSet = Core.Name "ValueSet" + +_NodeConstraintSequence5_listOfXsFacet = Core.Name "listOfXsFacet" + +-- | ShEx grammar production: NonLiteralKind ::= 'IRI' | 'BNODE' | 'NONLITERAL' +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" + +-- | ShEx grammar production: NotStartAction ::= start | shapeExprDecl +data NotStartAction = + NotStartActionStart ShapeExpression | + NotStartActionDeclaration NotStartActionShapeExprDecl + deriving (Eq, Ord, Read, Show) + +_NotStartAction = Core.Name "hydra.shex.syntax.NotStartAction" + +_NotStartAction_start = Core.Name "start" + +_NotStartAction_declaration = Core.Name "declaration" + +-- | A component of the ShEx NotStartActionShapeExprDecl production +data NotStartActionShapeExprDecl = + NotStartActionShapeExprDecl { + notStartActionShapeExprDeclShapeExprLabel :: ShapeExprLabel, + notStartActionShapeExprDeclAlts :: NotStartActionShapeExprDeclAlts} + deriving (Eq, Ord, Read, Show) + +_NotStartActionShapeExprDecl = Core.Name "hydra.shex.syntax.NotStartActionShapeExprDecl" + +_NotStartActionShapeExprDecl_ShapeExprLabel = Core.Name "ShapeExprLabel" + +_NotStartActionShapeExprDecl_alts = Core.Name "alts" + +-- | A synthetic Hydra type representing the alternatives of the ShEx NotStartActionShapeExprDecl production +data NotStartActionShapeExprDeclAlts = + NotStartActionShapeExprDeclAltsShapeExpression ShapeExpression | + NotStartActionShapeExprDeclAltsEXTERNAL + deriving (Eq, Ord, Read, Show) + +_NotStartActionShapeExprDeclAlts = Core.Name "hydra.shex.syntax.NotStartActionShapeExprDeclAlts" + +_NotStartActionShapeExprDeclAlts_ShapeExpression = Core.Name "ShapeExpression" + +_NotStartActionShapeExprDeclAlts_EXTERNAL = Core.Name "EXTERNAL" + +-- | A component of the ShEx NumericFacet production +data NumericFacet = + NumericFacetSeq NumericFacetSequence | + NumericFacetSeq2 NumericFacetSequence2 + deriving (Eq, Ord, Read, Show) + +_NumericFacet = Core.Name "hydra.shex.syntax.NumericFacet" + +_NumericFacet_seq = Core.Name "seq" + +_NumericFacet_seq2 = Core.Name "seq2" + +-- | A synthetic Hydra type representing a sequence within the ShEx NumericFacet production +data NumericFacetSequence = + NumericFacetSequence { + numericFacetSequenceNumericRange :: NumericRange, + numericFacetSequenceNumericLiteral :: NumericLiteral} + deriving (Eq, Ord, Read, Show) + +_NumericFacetSequence = Core.Name "hydra.shex.syntax.NumericFacetSequence" + +_NumericFacetSequence_NumericRange = Core.Name "NumericRange" + +_NumericFacetSequence_NumericLiteral = Core.Name "NumericLiteral" + +-- | A synthetic Hydra type representing a secondary sequence within the ShEx NumericFacet production +data NumericFacetSequence2 = + NumericFacetSequence2 { + numericFacetSequence2NumericLength :: NumericLength, + numericFacetSequence2Integer :: Integer_} + deriving (Eq, Ord, Read, Show) + +_NumericFacetSequence2 = Core.Name "hydra.shex.syntax.NumericFacetSequence2" + +_NumericFacetSequence2_NumericLength = Core.Name "NumericLength" + +_NumericFacetSequence2_Integer = Core.Name "Integer" + +-- | A component of the ShEx NumericLength production +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" + +-- | ShEx grammar production: NumericLiteral ::= Integer | Decimal | Double +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" + +-- | A component of the ShEx NumericRange production +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" + +-- | ShEx grammar production: OneOfTripleExpr ::= GroupTripleExpr | MultiElementOneOf +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" + +-- | ShEx grammar production: Percent ::= '%' Hex Hex +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" + +-- | ShEx grammar production: Plx ::= Percent | PnLocalEsc +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" + +-- | A component of the ShEx PnChars production +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" + +-- | A component of the ShEx PnCharsBase production +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" + +-- | ShEx grammar production: PnCharsU ::= PnCharsBase | '_' +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" + +-- | A component of the ShEx PnLocal production +data PnLocal = + PnLocal { + pnLocalAlts :: PnLocalAlts, + pnLocalSequence :: (Maybe PnLocalSequenceOption)} + deriving (Eq, Ord, Read, Show) + +_PnLocal = Core.Name "hydra.shex.syntax.PnLocal" + +_PnLocal_alts = Core.Name "alts" + +_PnLocal_Sequence = Core.Name "Sequence" + +-- | A synthetic Hydra type representing the alternatives of the ShEx PnLocal production +data PnLocalAlts = + PnLocalAltsPnCharsU PnCharsU | + PnLocalAltsColon | + PnLocalAltsRegex String | + PnLocalAltsPlx Plx + deriving (Eq, Ord, Read, Show) + +_PnLocalAlts = Core.Name "hydra.shex.syntax.PnLocalAlts" + +_PnLocalAlts_PnCharsU = Core.Name "PnCharsU" + +_PnLocalAlts_Colon = Core.Name "Colon" + +_PnLocalAlts_regex = Core.Name "regex" + +_PnLocalAlts_Plx = Core.Name "Plx" + +-- | A component of the ShEx PnLocalEsc production +newtype PnLocalEsc = + PnLocalEsc { + unPnLocalEsc :: String} + deriving (Eq, Ord, Read, Show) + +_PnLocalEsc = Core.Name "hydra.shex.syntax.PnLocalEsc" + +-- | A synthetic Hydra type representing an optional group within the ShEx PnLocal production +data PnLocalSequenceOption = + PnLocalSequenceOption { + pnLocalSequenceOptionListOfAlts :: [PnLocalSequenceOptionListOfAltsElmt], + pnLocalSequenceOptionAlts :: PnLocalSequenceOptionAlts} + deriving (Eq, Ord, Read, Show) + +_PnLocalSequenceOption = Core.Name "hydra.shex.syntax.PnLocalSequenceOption" + +_PnLocalSequenceOption_listOfAlts = Core.Name "listOfAlts" + +_PnLocalSequenceOption_alts = Core.Name "alts" + +-- | A synthetic Hydra type representing the alternatives of an optional group within the ShEx PnLocal production +data PnLocalSequenceOptionAlts = + PnLocalSequenceOptionAltsPnChars PnChars | + PnLocalSequenceOptionAltsColon | + PnLocalSequenceOptionAltsPlx Plx + deriving (Eq, Ord, Read, Show) + +_PnLocalSequenceOptionAlts = Core.Name "hydra.shex.syntax.PnLocalSequenceOptionAlts" + +_PnLocalSequenceOptionAlts_PnChars = Core.Name "PnChars" + +_PnLocalSequenceOptionAlts_Colon = Core.Name "Colon" + +_PnLocalSequenceOptionAlts_Plx = Core.Name "Plx" + +-- | A synthetic Hydra type representing one alternative of an optional repeated group within the ShEx PnLocal production +data PnLocalSequenceOptionListOfAltsElmt = + PnLocalSequenceOptionListOfAltsElmtPnChars PnChars | + PnLocalSequenceOptionListOfAltsElmtPeriod | + PnLocalSequenceOptionListOfAltsElmtColon | + PnLocalSequenceOptionListOfAltsElmtPlx Plx + deriving (Eq, Ord, Read, Show) + +_PnLocalSequenceOptionListOfAltsElmt = Core.Name "hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmt" + +_PnLocalSequenceOptionListOfAltsElmt_PnChars = Core.Name "PnChars" + +_PnLocalSequenceOptionListOfAltsElmt_Period = Core.Name "Period" + +_PnLocalSequenceOptionListOfAltsElmt_Colon = Core.Name "Colon" + +_PnLocalSequenceOptionListOfAltsElmt_Plx = Core.Name "Plx" + +-- | A component of the ShEx PnPrefix production +data PnPrefix = + PnPrefix { + pnPrefixPnCharsBase :: PnCharsBase, + pnPrefixSequence :: (Maybe PnPrefixSequenceOption)} + deriving (Eq, Ord, Read, Show) + +_PnPrefix = Core.Name "hydra.shex.syntax.PnPrefix" + +_PnPrefix_PnCharsBase = Core.Name "PnCharsBase" + +_PnPrefix_Sequence = Core.Name "Sequence" + +-- | A synthetic Hydra type representing an optional group within the ShEx PnPrefix production +data PnPrefixSequenceOption = + PnPrefixSequenceOption { + pnPrefixSequenceOptionAlts :: PnPrefixSequenceOptionAlts, + pnPrefixSequenceOptionPnChars :: PnChars} + deriving (Eq, Ord, Read, Show) + +_PnPrefixSequenceOption = Core.Name "hydra.shex.syntax.PnPrefixSequenceOption" + +_PnPrefixSequenceOption_alts = Core.Name "alts" + +_PnPrefixSequenceOption_PnChars = Core.Name "PnChars" + +-- | A synthetic Hydra type representing the alternatives of an optional group within the ShEx PnPrefix production +data PnPrefixSequenceOptionAlts = + PnPrefixSequenceOptionAltsPnChars PnChars | + PnPrefixSequenceOptionAltsPeriod + deriving (Eq, Ord, Read, Show) + +_PnPrefixSequenceOptionAlts = Core.Name "hydra.shex.syntax.PnPrefixSequenceOptionAlts" + +_PnPrefixSequenceOptionAlts_PnChars = Core.Name "PnChars" + +_PnPrefixSequenceOptionAlts_Period = Core.Name "Period" + +-- | ShEx grammar production: PnameLn ::= PnameNs PnLocal +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" + +-- | ShEx grammar production: PnameNs ::= PnPrefix? ':' +newtype PnameNs = + PnameNs { + unPnameNs :: (Maybe PnPrefix)} + deriving (Eq, Ord, Read, Show) + +_PnameNs = Core.Name "hydra.shex.syntax.PnameNs" + +-- | ShEx grammar production: Predicate ::= Iri | RdfType +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" + +-- | ShEx grammar production: PrefixDecl ::= 'PREFIX' PnameNs IriRef +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" + +-- | ShEx grammar production: PrefixedName ::= PnameLn | PnameNs +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" + +-- | ShEx grammar production: RdfLiteral ::= String (LangTag | '^^' Datatype)? +data RdfLiteral = + RdfLiteral { + rdfLiteralString :: String_, + rdfLiteralAlts :: (Maybe RdfLiteralAltsOption)} + deriving (Eq, Ord, Read, Show) + +_RdfLiteral = Core.Name "hydra.shex.syntax.RdfLiteral" + +_RdfLiteral_String = Core.Name "String" + +_RdfLiteral_Alts = Core.Name "Alts" + +-- | A synthetic Hydra type representing an optional alternative within the ShEx RdfLiteral production +data RdfLiteralAltsOption = + RdfLiteralAltsOptionLangTag LangTag | + RdfLiteralAltsOptionSequence Datatype + deriving (Eq, Ord, Read, Show) + +_RdfLiteralAltsOption = Core.Name "hydra.shex.syntax.RdfLiteralAltsOption" + +_RdfLiteralAltsOption_LangTag = Core.Name "LangTag" + +_RdfLiteralAltsOption_sequence = Core.Name "sequence" + +-- | ShEx grammar production: RdfType ::= 'a' +newtype RdfType = + RdfType { + unRdfType :: ()} + deriving (Eq, Ord, Read, Show) + +_RdfType = Core.Name "hydra.shex.syntax.RdfType" + +-- | A component of the ShEx Regexp production +data Regexp = + Regexp { + regexpListOfAlts :: [RegexpListOfAltsElmt], + regexpListOfRegex :: [String]} + deriving (Eq, Ord, Read, Show) + +_Regexp = Core.Name "hydra.shex.syntax.Regexp" + +_Regexp_listOfAlts = Core.Name "listOfAlts" + +_Regexp_listOfRegex = Core.Name "listOfRegex" + +-- | A synthetic Hydra type representing one element of the ShEx RegexpListOfAlts production +data RegexpListOfAltsElmt = + RegexpListOfAltsElmtRegex String | + RegexpListOfAltsElmtSequence String | + RegexpListOfAltsElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_RegexpListOfAltsElmt = Core.Name "hydra.shex.syntax.RegexpListOfAltsElmt" + +_RegexpListOfAltsElmt_regex = Core.Name "regex" + +_RegexpListOfAltsElmt_sequence = Core.Name "sequence" + +_RegexpListOfAltsElmt_Uchar = Core.Name "Uchar" + +-- | A component of the ShEx RepeatRange production +data RepeatRange = + RepeatRange { + repeatRangeInteger :: Integer_, + repeatRangeSequence :: (Maybe (Maybe (Maybe RepeatRangeSequenceOptionOptionOption)))} + deriving (Eq, Ord, Read, Show) + +_RepeatRange = Core.Name "hydra.shex.syntax.RepeatRange" + +_RepeatRange_Integer = Core.Name "Integer" + +_RepeatRange_Sequence = Core.Name "Sequence" + +-- | A synthetic Hydra type representing a nested optional group within the ShEx RepeatRange production +data RepeatRangeSequenceOptionOptionOption = + RepeatRangeSequenceOptionOptionOptionInteger Integer_ | + RepeatRangeSequenceOptionOptionOptionAst + deriving (Eq, Ord, Read, Show) + +_RepeatRangeSequenceOptionOptionOption = Core.Name "hydra.shex.syntax.RepeatRangeSequenceOptionOptionOption" + +_RepeatRangeSequenceOptionOptionOption_Integer = Core.Name "Integer" + +_RepeatRangeSequenceOptionOptionOption_Ast = Core.Name "Ast" + +-- | ShEx grammar production: SemanticActions ::= CodeDecl* +newtype SemanticActions = + SemanticActions { + unSemanticActions :: [CodeDecl]} + deriving (Eq, Ord, Read, Show) + +_SemanticActions = Core.Name "hydra.shex.syntax.SemanticActions" + +-- | ShEx grammar production: SenseFlags ::= '^' +newtype SenseFlags = + SenseFlags { + unSenseFlags :: ()} + deriving (Eq, Ord, Read, Show) + +_SenseFlags = Core.Name "hydra.shex.syntax.SenseFlags" + +-- | ShEx grammar production: ShapeAnd ::= ShapeNot ('AND' ShapeNot)* +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" + +-- | A component of the ShEx ShapeAtom production +data ShapeAtom = + ShapeAtomSeq ShapeAtomSequence | + ShapeAtomShapeOrRef ShapeOrRef | + ShapeAtomSequence2 ShapeExpression | + ShapeAtomPeriod + deriving (Eq, Ord, Read, Show) + +_ShapeAtom = Core.Name "hydra.shex.syntax.ShapeAtom" + +_ShapeAtom_seq = Core.Name "seq" + +_ShapeAtom_ShapeOrRef = Core.Name "ShapeOrRef" + +_ShapeAtom_sequence2 = Core.Name "sequence2" + +_ShapeAtom_Period = Core.Name "Period" + +-- | A synthetic Hydra type representing a sequence within the ShEx ShapeAtom production +data ShapeAtomSequence = + ShapeAtomSequence { + shapeAtomSequenceNodeConstraint :: NodeConstraint, + shapeAtomSequenceShapeOrRef :: (Maybe ShapeOrRef)} + deriving (Eq, Ord, Read, Show) + +_ShapeAtomSequence = Core.Name "hydra.shex.syntax.ShapeAtomSequence" + +_ShapeAtomSequence_NodeConstraint = Core.Name "NodeConstraint" + +_ShapeAtomSequence_ShapeOrRef = Core.Name "ShapeOrRef" + +-- | A component of the ShEx ShapeDefinition production +data ShapeDefinition = + ShapeDefinition { + shapeDefinitionListOfAlts :: [ShapeDefinitionListOfAltsElmt], + 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" + +-- | A synthetic Hydra type representing one element of the ShEx ShapeDefinitionListOfAlts production +data ShapeDefinitionListOfAltsElmt = + ShapeDefinitionListOfAltsElmtIncludeSet IncludeSet | + ShapeDefinitionListOfAltsElmtExtraPropertySet ExtraPropertySet | + ShapeDefinitionListOfAltsElmtCLOSED + deriving (Eq, Ord, Read, Show) + +_ShapeDefinitionListOfAltsElmt = Core.Name "hydra.shex.syntax.ShapeDefinitionListOfAltsElmt" + +_ShapeDefinitionListOfAltsElmt_IncludeSet = Core.Name "IncludeSet" + +_ShapeDefinitionListOfAltsElmt_ExtraPropertySet = Core.Name "ExtraPropertySet" + +_ShapeDefinitionListOfAltsElmt_CLOSED = Core.Name "CLOSED" + +-- | ShEx grammar production: ShapeExprLabel ::= Iri | BlankNode +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" + +-- | ShEx grammar production: ShapeExpression ::= ShapeOr +newtype ShapeExpression = + ShapeExpression { + unShapeExpression :: ShapeOr} + deriving (Eq, Ord, Read, Show) + +_ShapeExpression = Core.Name "hydra.shex.syntax.ShapeExpression" + +-- | ShEx grammar production: ShapeNot ::= 'NOT'? ShapeAtom +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" + +-- | ShEx grammar production: ShapeOr ::= ShapeAnd ('OR' ShapeAnd)* +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" + +-- | A component of the ShEx ShapeOrRef production +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" + +-- | ShEx grammar production: ShexDoc ::= Directive* ((NotStartAction | StartActions) Statement*)? +data ShexDoc = + ShexDoc { + shexDocListOfDirective :: [Directive], + shexDocSequence :: (Maybe ShexDocSequenceOption), + 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" + +-- | A synthetic Hydra type representing an optional group within the ShEx ShexDoc production +data ShexDocSequenceOption = + ShexDocSequenceOption { + shexDocSequenceOptionAlts :: ShexDocSequenceOptionAlts, + shexDocSequenceOptionListOfStatement :: [Statement]} + deriving (Eq, Ord, Read, Show) + +_ShexDocSequenceOption = Core.Name "hydra.shex.syntax.ShexDocSequenceOption" + +_ShexDocSequenceOption_alts = Core.Name "alts" + +_ShexDocSequenceOption_listOfStatement = Core.Name "listOfStatement" + +-- | A synthetic Hydra type representing the alternatives of an optional group within the ShEx ShexDoc production +data ShexDocSequenceOptionAlts = + ShexDocSequenceOptionAltsNotStartAction NotStartAction | + ShexDocSequenceOptionAltsStartActions StartActions + deriving (Eq, Ord, Read, Show) + +_ShexDocSequenceOptionAlts = Core.Name "hydra.shex.syntax.ShexDocSequenceOptionAlts" + +_ShexDocSequenceOptionAlts_NotStartAction = Core.Name "NotStartAction" + +_ShexDocSequenceOptionAlts_StartActions = Core.Name "StartActions" + +-- | ShEx grammar production: SingleElementGroup ::= UnaryTripleExpr ';'? +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" + +-- | ShEx grammar production: StartActions ::= CodeDecl+ +newtype StartActions = + StartActions { + unStartActions :: [CodeDecl]} + deriving (Eq, Ord, Read, Show) + +_StartActions = Core.Name "hydra.shex.syntax.StartActions" + +-- | ShEx grammar production: Statement ::= Directive | NotStartAction +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" + +-- | A component of the ShEx String production +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" + +-- | ShEx grammar production: StringFacet ::= StringLength Integer | Regexp +data StringFacet = + StringFacetSeq StringFacetSequence | + StringFacetRegexp Regexp + deriving (Eq, Ord, Read, Show) + +_StringFacet = Core.Name "hydra.shex.syntax.StringFacet" + +_StringFacet_seq = Core.Name "seq" + +_StringFacet_Regexp = Core.Name "Regexp" + +-- | A synthetic Hydra type representing a sequence within the ShEx StringFacet production +data StringFacetSequence = + StringFacetSequence { + stringFacetSequenceStringLength :: StringLength, + stringFacetSequenceInteger :: Integer_} + deriving (Eq, Ord, Read, Show) + +_StringFacetSequence = Core.Name "hydra.shex.syntax.StringFacetSequence" + +_StringFacetSequence_StringLength = Core.Name "StringLength" + +_StringFacetSequence_Integer = Core.Name "Integer" + +-- | ShEx grammar production: StringLength ::= 'LENGTH' | 'MINLENGTH' | 'MAXLENGTH' +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" + +-- | A component of the ShEx StringLiteral1 production +newtype StringLiteral1 = + StringLiteral1 { + unStringLiteral1 :: [StringLiteral1Elmt]} + deriving (Eq, Ord, Read, Show) + +_StringLiteral1 = Core.Name "hydra.shex.syntax.StringLiteral1" + +-- | A synthetic Hydra type representing one element of the ShEx StringLiteral1 production +data StringLiteral1Elmt = + StringLiteral1ElmtRegex String | + StringLiteral1ElmtEchar Echar | + StringLiteral1ElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_StringLiteral1Elmt = Core.Name "hydra.shex.syntax.StringLiteral1Elmt" + +_StringLiteral1Elmt_regex = Core.Name "regex" + +_StringLiteral1Elmt_Echar = Core.Name "Echar" + +_StringLiteral1Elmt_Uchar = Core.Name "Uchar" + +-- | A component of the ShEx StringLiteral2 production +newtype StringLiteral2 = + StringLiteral2 { + unStringLiteral2 :: [StringLiteral2Elmt]} + deriving (Eq, Ord, Read, Show) + +_StringLiteral2 = Core.Name "hydra.shex.syntax.StringLiteral2" + +-- | A synthetic Hydra type representing one element of the ShEx StringLiteral2 production +data StringLiteral2Elmt = + StringLiteral2ElmtRegex String | + StringLiteral2ElmtEchar Echar | + StringLiteral2ElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_StringLiteral2Elmt = Core.Name "hydra.shex.syntax.StringLiteral2Elmt" + +_StringLiteral2Elmt_regex = Core.Name "regex" + +_StringLiteral2Elmt_Echar = Core.Name "Echar" + +_StringLiteral2Elmt_Uchar = Core.Name "Uchar" + +-- | A component of the ShEx StringLiteralLong1 production +newtype StringLiteralLong1 = + StringLiteralLong1 { + unStringLiteralLong1 :: [StringLiteralLong1Elmt]} + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong1 = Core.Name "hydra.shex.syntax.StringLiteralLong1" + +-- | A synthetic Hydra type representing one element of the ShEx StringLiteralLong1 production +data StringLiteralLong1Elmt = + StringLiteralLong1ElmtSeq StringLiteralLong1ElmtSequence | + StringLiteralLong1ElmtEchar Echar | + StringLiteralLong1ElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong1Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong1Elmt" + +_StringLiteralLong1Elmt_seq = Core.Name "seq" + +_StringLiteralLong1Elmt_Echar = Core.Name "Echar" + +_StringLiteralLong1Elmt_Uchar = Core.Name "Uchar" + +-- | A synthetic Hydra type representing a sequence within an element of the ShEx StringLiteralLong1 production +data StringLiteralLong1ElmtSequence = + StringLiteralLong1ElmtSequence { + stringLiteralLong1ElmtSequenceAlts :: (Maybe StringLiteralLong1ElmtSequenceAltsOption), + stringLiteralLong1ElmtSequenceRegex :: String} + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong1ElmtSequence = Core.Name "hydra.shex.syntax.StringLiteralLong1ElmtSequence" + +_StringLiteralLong1ElmtSequence_Alts = Core.Name "Alts" + +_StringLiteralLong1ElmtSequence_regex = Core.Name "regex" + +-- | A synthetic Hydra type representing an optional alternative of an element of the ShEx StringLiteralLong1 production +data StringLiteralLong1ElmtSequenceAltsOption = + StringLiteralLong1ElmtSequenceAltsOptionApos | + StringLiteralLong1ElmtSequenceAltsOptionSeq StringLiteralLong1ElmtSequenceAltsOptionSequence + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong1ElmtSequenceAltsOption = Core.Name "hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOption" + +_StringLiteralLong1ElmtSequenceAltsOption_Apos = Core.Name "Apos" + +_StringLiteralLong1ElmtSequenceAltsOption_seq = Core.Name "seq" + +-- | A synthetic Hydra type representing a sequence within an optional alternative of an element of the ShEx StringLiteralLong1 production +type StringLiteralLong1ElmtSequenceAltsOptionSequence = () + +_StringLiteralLong1ElmtSequenceAltsOptionSequence = + Core.Name "hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOptionSequence" + +-- | A component of the ShEx StringLiteralLong2 production +newtype StringLiteralLong2 = + StringLiteralLong2 { + unStringLiteralLong2 :: [StringLiteralLong2Elmt]} + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong2 = Core.Name "hydra.shex.syntax.StringLiteralLong2" + +-- | A synthetic Hydra type representing one element of the ShEx StringLiteralLong2 production +data StringLiteralLong2Elmt = + StringLiteralLong2ElmtSeq StringLiteralLong2ElmtSequence | + StringLiteralLong2ElmtEchar Echar | + StringLiteralLong2ElmtUchar Uchar + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong2Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong2Elmt" + +_StringLiteralLong2Elmt_seq = Core.Name "seq" + +_StringLiteralLong2Elmt_Echar = Core.Name "Echar" + +_StringLiteralLong2Elmt_Uchar = Core.Name "Uchar" + +-- | A synthetic Hydra type representing a sequence within an element of the ShEx StringLiteralLong2 production +data StringLiteralLong2ElmtSequence = + StringLiteralLong2ElmtSequence { + stringLiteralLong2ElmtSequenceAlts :: (Maybe StringLiteralLong2ElmtSequenceAltsOption), + stringLiteralLong2ElmtSequenceRegex :: String} + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong2ElmtSequence = Core.Name "hydra.shex.syntax.StringLiteralLong2ElmtSequence" + +_StringLiteralLong2ElmtSequence_Alts = Core.Name "Alts" + +_StringLiteralLong2ElmtSequence_regex = Core.Name "regex" + +-- | A synthetic Hydra type representing an optional alternative of an element of the ShEx StringLiteralLong2 production +data StringLiteralLong2ElmtSequenceAltsOption = + StringLiteralLong2ElmtSequenceAltsOptionQuot | + StringLiteralLong2ElmtSequenceAltsOptionSeq StringLiteralLong2ElmtSequenceAltsOptionSequence + deriving (Eq, Ord, Read, Show) + +_StringLiteralLong2ElmtSequenceAltsOption = Core.Name "hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOption" + +_StringLiteralLong2ElmtSequenceAltsOption_Quot = Core.Name "Quot" + +_StringLiteralLong2ElmtSequenceAltsOption_seq = Core.Name "seq" + +-- | A synthetic Hydra type representing a sequence within an optional alternative of an element of the ShEx StringLiteralLong2 production +type StringLiteralLong2ElmtSequenceAltsOptionSequence = () + +_StringLiteralLong2ElmtSequenceAltsOptionSequence = + Core.Name "hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOptionSequence" + +-- | A component of the ShEx TripleConstraint production +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" + +-- | ShEx grammar production: TripleExprLabel ::= Iri | 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" + +-- | ShEx grammar production: TripleExpression ::= OneOfTripleExpr +newtype TripleExpression = + TripleExpression { + unTripleExpression :: OneOfTripleExpr} + deriving (Eq, Ord, Read, Show) + +_TripleExpression = Core.Name "hydra.shex.syntax.TripleExpression" + +-- | A component of the ShEx Uchar production +data Uchar = + UcharSeq UcharSequence | + UcharSeq2 UcharSequence2 + deriving (Eq, Ord, Read, Show) + +_Uchar = Core.Name "hydra.shex.syntax.Uchar" + +_Uchar_seq = Core.Name "seq" + +_Uchar_seq2 = Core.Name "seq2" + +-- | A synthetic Hydra type representing a sequence within the ShEx Uchar production +data UcharSequence = + UcharSequence { + ucharSequenceHex :: Hex, + ucharSequenceHex2 :: Hex, + ucharSequenceHex3 :: Hex, + ucharSequenceHex4 :: Hex} + deriving (Eq, Ord, Read, Show) + +_UcharSequence = Core.Name "hydra.shex.syntax.UcharSequence" + +_UcharSequence_Hex = Core.Name "Hex" + +_UcharSequence_Hex2 = Core.Name "Hex2" + +_UcharSequence_Hex3 = Core.Name "Hex3" + +_UcharSequence_Hex4 = Core.Name "Hex4" + +-- | A synthetic Hydra type representing a secondary sequence within the ShEx Uchar production +data UcharSequence2 = + UcharSequence2 { + ucharSequence2Hex :: Hex, + ucharSequence2Hex2 :: Hex, + ucharSequence2Hex3 :: Hex, + ucharSequence2Hex4 :: Hex, + ucharSequence2Hex5 :: Hex, + ucharSequence2Hex6 :: Hex, + ucharSequence2Hex7 :: Hex, + ucharSequence2Hex8 :: Hex} + deriving (Eq, Ord, Read, Show) + +_UcharSequence2 = Core.Name "hydra.shex.syntax.UcharSequence2" + +_UcharSequence2_Hex = Core.Name "Hex" + +_UcharSequence2_Hex2 = Core.Name "Hex2" + +_UcharSequence2_Hex3 = Core.Name "Hex3" + +_UcharSequence2_Hex4 = Core.Name "Hex4" + +_UcharSequence2_Hex5 = Core.Name "Hex5" + +_UcharSequence2_Hex6 = Core.Name "Hex6" + +_UcharSequence2_Hex7 = Core.Name "Hex7" + +_UcharSequence2_Hex8 = Core.Name "Hex8" + +-- | A component of the ShEx UnaryTripleExpr production +data UnaryTripleExpr = + UnaryTripleExprSeq UnaryTripleExprSequence | + UnaryTripleExprInclude Include + deriving (Eq, Ord, Read, Show) + +_UnaryTripleExpr = Core.Name "hydra.shex.syntax.UnaryTripleExpr" + +_UnaryTripleExpr_seq = Core.Name "seq" + +_UnaryTripleExpr_Include = Core.Name "Include" + +-- | A synthetic Hydra type representing a sequence within the ShEx UnaryTripleExpr production +data UnaryTripleExprSequence = + UnaryTripleExprSequence { + unaryTripleExprSequenceSequence :: (Maybe TripleExprLabel), + unaryTripleExprSequenceAlts :: UnaryTripleExprSequenceAlts} + deriving (Eq, Ord, Read, Show) + +_UnaryTripleExprSequence = Core.Name "hydra.shex.syntax.UnaryTripleExprSequence" + +_UnaryTripleExprSequence_Sequence = Core.Name "Sequence" + +_UnaryTripleExprSequence_alts = Core.Name "alts" + +-- | A synthetic Hydra type representing the alternatives of the ShEx UnaryTripleExprSequence production +data UnaryTripleExprSequenceAlts = + UnaryTripleExprSequenceAltsTripleConstraint TripleConstraint | + UnaryTripleExprSequenceAltsBracketedTripleExpr BracketedTripleExpr + deriving (Eq, Ord, Read, Show) + +_UnaryTripleExprSequenceAlts = Core.Name "hydra.shex.syntax.UnaryTripleExprSequenceAlts" + +_UnaryTripleExprSequenceAlts_TripleConstraint = Core.Name "TripleConstraint" + +_UnaryTripleExprSequenceAlts_BracketedTripleExpr = Core.Name "BracketedTripleExpr" + +-- | ShEx grammar production: ValueSet ::= '[' ValueSetValue* ']' +newtype ValueSet = + ValueSet { + unValueSet :: [ValueSetValue]} + deriving (Eq, Ord, Read, Show) + +_ValueSet = Core.Name "hydra.shex.syntax.ValueSet" + +-- | ShEx grammar production: ValueSetValue ::= IriRange | Literal +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" + +-- | ShEx grammar production: XsFacet ::= StringFacet | NumericFacet +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" diff --git a/src/main/haskell/Hydra/Xml/Schema.hs b/src/main/haskell/Hydra/Xml/Schema.hs --- a/src/main/haskell/Hydra/Xml/Schema.hs +++ b/src/main/haskell/Hydra/Xml/Schema.hs @@ -1,4 +1,5 @@ -- 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 @@ -6,324 +7,506 @@ -- | 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 + +-- | The XSD anySimpleType, the base type of all simple (non-list, non-union-composed) XML Schema datatypes newtype AnySimpleType = AnySimpleType { unAnySimpleType :: String} deriving (Eq, Ord, Read, Show) + _AnySimpleType = Core.Name "hydra.xml.schema.AnySimpleType" + +-- | The XSD anyType, the root of the XML Schema type hierarchy newtype AnyType = AnyType { unAnyType :: String} deriving (Eq, Ord, Read, Show) + _AnyType = Core.Name "hydra.xml.schema.AnyType" + +-- | The XSD anyURI datatype: a URI reference newtype AnyURI = AnyURI { unAnyURI :: String} deriving (Eq, Ord, Read, Show) + _AnyURI = Core.Name "hydra.xml.schema.AnyURI" + +-- | The XSD base64Binary datatype: arbitrary binary data encoded as base64 newtype Base64Binary = Base64Binary { unBase64Binary :: String} deriving (Eq, Ord, Read, Show) + _Base64Binary = Core.Name "hydra.xml.schema.Base64Binary" + +-- | The XSD boolean datatype: true or false newtype Boolean = Boolean { unBoolean :: Bool} deriving (Eq, Ord, Read, Show) + _Boolean = Core.Name "hydra.xml.schema.Boolean" + +-- | The XSD byte datatype: an 8-bit signed integer newtype Byte = Byte { unByte :: I.Int8} deriving (Eq, Ord, Read, Show) + _Byte = Core.Name "hydra.xml.schema.Byte" + +-- | An XML Schema constraining facet, restricting the value space of a datatype +newtype ConstrainingFacet = + ConstrainingFacet { + unConstrainingFacet :: ()} + deriving (Eq, Ord, Read, Show) + +_ConstrainingFacet = Core.Name "hydra.xml.schema.ConstrainingFacet" + +-- | The name of a built-in XML Schema datatype +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" + +-- | The XSD date datatype: a calendar date, optionally with a timezone newtype Date = Date { unDate :: String} deriving (Eq, Ord, Read, Show) + _Date = Core.Name "hydra.xml.schema.Date" + +-- | The XSD dateTime datatype: a date and time, optionally with a timezone newtype DateTime = DateTime { unDateTime :: String} deriving (Eq, Ord, Read, Show) + _DateTime = Core.Name "hydra.xml.schema.DateTime" + +-- | The XSD decimal datatype: an arbitrary-precision signed decimal number newtype Decimal = Decimal { unDecimal :: String} deriving (Eq, Ord, Read, Show) + _Decimal = Core.Name "hydra.xml.schema.Decimal" + +-- | The XSD double datatype: an IEEE 754 double-precision floating-point number newtype Double_ = Double_ { unDouble :: Double} deriving (Eq, Ord, Read, Show) + _Double = Core.Name "hydra.xml.schema.Double" + +-- | The XSD duration datatype: a duration of time newtype Duration = Duration { unDuration :: String} deriving (Eq, Ord, Read, Show) + _Duration = Core.Name "hydra.xml.schema.Duration" + +-- | The XSD ENTITIES datatype: a whitespace-separated list of unparsed entity names newtype ENTITIES = ENTITIES { unENTITIES :: String} deriving (Eq, Ord, Read, Show) + _ENTITIES = Core.Name "hydra.xml.schema.ENTITIES" + +-- | The XSD ENTITY datatype: the name of an unparsed entity newtype ENTITY = ENTITY { unENTITY :: String} deriving (Eq, Ord, Read, Show) + _ENTITY = Core.Name "hydra.xml.schema.ENTITY" + +-- | The XSD float datatype: an IEEE 754 single-precision floating-point number newtype Float_ = Float_ { unFloat :: Float} deriving (Eq, Ord, Read, Show) + _Float = Core.Name "hydra.xml.schema.Float" + +-- | The XSD gDay datatype: a day of the month, recurring newtype GDay = GDay { unGDay :: String} deriving (Eq, Ord, Read, Show) + _GDay = Core.Name "hydra.xml.schema.GDay" + +-- | The XSD gMonth datatype: a month of the year, recurring newtype GMonth = GMonth { unGMonth :: String} deriving (Eq, Ord, Read, Show) + _GMonth = Core.Name "hydra.xml.schema.GMonth" + +-- | The XSD gMonthDay datatype: a day of a specific month, recurring yearly newtype GMonthDay = GMonthDay { unGMonthDay :: String} deriving (Eq, Ord, Read, Show) + _GMonthDay = Core.Name "hydra.xml.schema.GMonthDay" + +-- | The XSD gYear datatype: a calendar year newtype GYear = GYear { unGYear :: String} deriving (Eq, Ord, Read, Show) + _GYear = Core.Name "hydra.xml.schema.GYear" + +-- | The XSD gYearMonth datatype: a specific month of a specific year newtype GYearMonth = GYearMonth { unGYearMonth :: String} deriving (Eq, Ord, Read, Show) + _GYearMonth = Core.Name "hydra.xml.schema.GYearMonth" + +-- | The XSD hexBinary datatype: arbitrary binary data encoded as hexadecimal newtype HexBinary = HexBinary { unHexBinary :: String} deriving (Eq, Ord, Read, Show) + _HexBinary = Core.Name "hydra.xml.schema.HexBinary" + +-- | The XSD ID datatype: an XML identifier attribute value, unique within a document newtype ID = ID { unID :: String} deriving (Eq, Ord, Read, Show) + _ID = Core.Name "hydra.xml.schema.ID" + +-- | The XSD IDREF datatype: a reference to an XML ID attribute value newtype IDREF = IDREF { unIDREF :: String} deriving (Eq, Ord, Read, Show) + _IDREF = Core.Name "hydra.xml.schema.IDREF" + +-- | The XSD IDREFS datatype: a whitespace-separated list of IDREF values newtype IDREFS = IDREFS { unIDREFS :: String} deriving (Eq, Ord, Read, Show) + _IDREFS = Core.Name "hydra.xml.schema.IDREFS" + +-- | The XSD int datatype: a 32-bit signed integer newtype Int_ = Int_ { unInt :: Int} deriving (Eq, Ord, Read, Show) + _Int = Core.Name "hydra.xml.schema.Int" + +-- | The XSD integer datatype: an arbitrary-precision signed integer newtype Integer_ = Integer_ { unInteger :: Integer} deriving (Eq, Ord, Read, Show) + _Integer = Core.Name "hydra.xml.schema.Integer" + +-- | The XSD language datatype: an RFC 3066 language tag newtype Language = Language { unLanguage :: String} deriving (Eq, Ord, Read, Show) + _Language = Core.Name "hydra.xml.schema.Language" + +-- | The XSD long datatype: a 64-bit signed integer newtype Long = Long { unLong :: I.Int64} deriving (Eq, Ord, Read, Show) + _Long = Core.Name "hydra.xml.schema.Long" + +-- | The XSD NMTOKEN datatype: an XML name token newtype NMTOKEN = NMTOKEN { unNMTOKEN :: String} deriving (Eq, Ord, Read, Show) + _NMTOKEN = Core.Name "hydra.xml.schema.NMTOKEN" + +-- | The XSD NOTATION datatype: the name of a notation declared in the document's DTD newtype NOTATION = NOTATION { unNOTATION :: String} deriving (Eq, Ord, Read, Show) + _NOTATION = Core.Name "hydra.xml.schema.NOTATION" + +-- | The XSD Name datatype: an XML Name (a token that may not start with a digit) newtype Name = Name { unName :: String} deriving (Eq, Ord, Read, Show) + _Name = Core.Name "hydra.xml.schema.Name" + +-- | The XSD negativeInteger datatype: an arbitrary-precision integer less than zero newtype NegativeInteger = NegativeInteger { unNegativeInteger :: Integer} deriving (Eq, Ord, Read, Show) + _NegativeInteger = Core.Name "hydra.xml.schema.NegativeInteger" + +-- | The XSD nonNegativeInteger datatype: an arbitrary-precision integer greater than or equal to zero newtype NonNegativeInteger = NonNegativeInteger { unNonNegativeInteger :: Integer} deriving (Eq, Ord, Read, Show) + _NonNegativeInteger = Core.Name "hydra.xml.schema.NonNegativeInteger" + +-- | The XSD nonPositiveInteger datatype: an arbitrary-precision integer less than or equal to zero newtype NonPositiveInteger = NonPositiveInteger { unNonPositiveInteger :: Integer} deriving (Eq, Ord, Read, Show) + _NonPositiveInteger = Core.Name "hydra.xml.schema.NonPositiveInteger" + +-- | The XSD normalizedString datatype: a string with no carriage return, line feed, or tab characters newtype NormalizedString = NormalizedString { unNormalizedString :: String} deriving (Eq, Ord, Read, Show) + _NormalizedString = Core.Name "hydra.xml.schema.NormalizedString" + +-- | The XSD positiveInteger datatype: an arbitrary-precision integer greater than zero newtype PositiveInteger = PositiveInteger { unPositiveInteger :: Integer} deriving (Eq, Ord, Read, Show) + _PositiveInteger = Core.Name "hydra.xml.schema.PositiveInteger" + +-- | The XSD QName datatype: a namespace-qualified XML name newtype QName = QName { unQName :: String} deriving (Eq, Ord, Read, Show) + _QName = Core.Name "hydra.xml.schema.QName" + +-- | The XSD short datatype: a 16-bit signed integer newtype Short = Short { unShort :: I.Int16} deriving (Eq, Ord, Read, Show) + _Short = Core.Name "hydra.xml.schema.Short" + +-- | The XSD string datatype: a character string newtype String_ = String_ { unString :: String} deriving (Eq, Ord, Read, Show) + _String = Core.Name "hydra.xml.schema.String" + +-- | The XSD time datatype: a time of day, optionally with a timezone newtype Time = Time { unTime :: String} deriving (Eq, Ord, Read, Show) + _Time = Core.Name "hydra.xml.schema.Time" + +-- | The XSD token datatype: a normalized string with no leading, trailing, or consecutive internal whitespace newtype Token = Token { unToken :: String} deriving (Eq, Ord, Read, Show) + _Token = Core.Name "hydra.xml.schema.Token" + +-- | The XSD unsignedByte datatype: an 8-bit unsigned integer newtype UnsignedByte = UnsignedByte { unUnsignedByte :: I.Int16} deriving (Eq, Ord, Read, Show) + _UnsignedByte = Core.Name "hydra.xml.schema.UnsignedByte" + +-- | The XSD unsignedInt datatype: a 32-bit unsigned integer newtype UnsignedInt = UnsignedInt { unUnsignedInt :: I.Int64} deriving (Eq, Ord, Read, Show) + _UnsignedInt = Core.Name "hydra.xml.schema.UnsignedInt" + +-- | The XSD unsignedLong datatype: a 64-bit unsigned integer newtype UnsignedLong = UnsignedLong { unUnsignedLong :: Integer} deriving (Eq, Ord, Read, Show) + _UnsignedLong = Core.Name "hydra.xml.schema.UnsignedLong" + +-- | The XSD unsignedShort datatype: a 16-bit unsigned integer 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"