packages feed

hydra-rdf 0.18.0 → 0.18.1

raw patch · 6 files changed

+248/−50 lines, 6 filesdep ~hydra-kernelPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

+ Hydra.Rdf.ShaclRdf: anonymousBlankNode :: Resource -> String -> Int -> Resource
+ Hydra.Rdf.ShaclRdf: escapeBlankNodeLabelPart :: String -> String
+ Hydra.Rdf.ShaclRdf: inlineNodeShapeToTriples :: Resource -> NodeShape -> [Triple]
+ Hydra.Rdf.ShaclRdf: inlineShapeToTriples :: Resource -> Shape -> [Triple]
+ Hydra.Rdf.ShaclRdf: rdfListToTriples :: Resource -> String -> [Node] -> [Triple]
+ Hydra.Rdf.ShaclRdf: referenceListToTriples :: Resource -> String -> (Resource -> t0 -> [Triple]) -> [Reference t0] -> [Triple]
+ Hydra.Rdf.ShaclRdf: referenceToObject :: Resource -> String -> (Resource -> t0 -> [t1]) -> Int -> Reference t0 -> Maybe (Node, [t1])
+ Hydra.Rdf.ShaclRdf: referenceToTriples :: Resource -> String -> (Resource -> t0 -> [Triple]) -> Int -> Reference t0 -> [Triple]
- Hydra.Rdf.ShaclRdf: propertyRefToTriples :: Resource -> Reference PropertyShape -> [Triple]
+ Hydra.Rdf.ShaclRdf: propertyRefToTriples :: Resource -> Int -> Reference PropertyShape -> [Triple]

Files

CHANGELOG.md view
@@ -15,6 +15,144 @@  --- +## [0.18.1] - 2026-11-20++Textual-sources release: the whole `hydra-kernel` is now authored as textual `.hydra` files, including the+primitive library `hydra.core.lib.*`, and the textual syntax gains the sugar, parsers, and tooling needed to carry it.+Also lands translingual tail-call optimization for the Scala and TypeScript coders, named provisions and+primitive parameter names, the property-graph encoding of term graphs, and a large body of host-specific bootstrap+and CI fixes.++### Breaking changes++- **Type renames** ([#837](https://github.com/CategoricalData/hydra/issues/837)): four types whose variant names clashed with other kernel types are renamed.+  Any code, JSON, or `.hydra` text that names them must be updated.+  - `hydra.core.regex.QuantifierRange` is now `hydra.core.regex.Range`.+  - `hydra.ext.azure.dtld.SchemaPrimitive` is now `PrimitiveSchema`, and `SchemaComplex` is now `ComplexSchema`.+  - `hydra.rust.syntax.TypePath` is now `PathType`.+- **New primitive signature syntax in `.hydra`** ([#837](https://github.com/CategoricalData/hydra/issues/837)): a `primitive` definition names its parameters,+  `primitive ifElse ∀x.(p: boolean, t: lazy x, f: lazy x) : x`, instead of the old arrow chain+  (`primitive ifElse : ∀t. boolean → lazy t → lazy t → t`).+  Parameter and result descriptions move into `@param` and `@return` doc lines.+  The arrow-chain form is for `term` signatures only.+- **Raw `case` keyword is now `cases`** ([#810](https://github.com/CategoricalData/hydra/issues/810)): the textual-syntax case statement keyword matches `Term.cases`.+- **`hydra.core.json.bootstrap` is now `hydra.core.bootstrap`** ([#791](https://github.com/CategoricalData/hydra/issues/791)).+- **`and` and `or` are lazy in their second operand** ([#802](https://github.com/CategoricalData/hydra/issues/802)): both are marked lazy, mirroring `ifElse`, and the+  Java and Python hosts add thunk-accepting overloads.++### Highlights++- **The whole kernel is `.hydra`-sourced** ([#837](https://github.com/CategoricalData/hydra/issues/837), [#711](https://github.com/CategoricalData/hydra/issues/711), [#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)):+  every `hydra-kernel` module, including all `hydra.core.lib.*` primitive modules and the test modules, is sourced from+  `packages/hydra-kernel/src/main/hydra/**/*.hydra`; Phase 1 reads that text instead of the Haskell DSL.+  The Haskell DSL modules remain as a twin that must stay byte-identical (the dual-edit rule).+  `bin/verify-hydra-sources.sh` is the identity guard (it is not run by CI),+  and `heads/haskell/bin/print-hydra-sources.sh` regenerates the text from the DSL.+  A package may textually source only modules it owns.+- **Named primitive parameters** ([#837](https://github.com/CategoricalData/hydra/issues/837)): all 292 primitives print with named parameters and `@param`/`@return`+  descriptions, carried through the kernel metadata.+- **`parseModules`** ([#842](https://github.com/CategoricalData/hydra/issues/842)): `hydra.core.parse.packaging.parseModules` reads `.hydra` text into modules and is the+  supported entry point for downstream code generation from textual sources+  (see `docs/recipes/downstream-codegen.md`).+- **Kernel JSON on the classpath** ([#786](https://github.com/CategoricalData/hydra/issues/786)): the published `hydra-kernel` jar bundles the kernel's JSON modules, so+  Java downstream projects no longer need a source checkout to load the kernel.+- **Tail-call optimization on more hosts** ([#709](https://github.com/CategoricalData/hydra/issues/709)): shared `TcoLoopPlan`/`TcoStep` kernel types and a+  `lowerSelfTailRecursion` pass, consumed by the new Scala (`@tailrec`) and TypeScript lowerings.+- **Named provisions** ([#725](https://github.com/CategoricalData/hydra/issues/725)): primitives and tests carry named requirements and recommendations,+  spec prose is ported into module and primitive metadata, and the generated spec pages render comments and lifecycle.+- **Term graphs as property graphs** ([#738](https://github.com/CategoricalData/hydra/issues/738)): `hydra.pg.subtermGraph` encodes a term graph as a property graph,+  with specification pages (`docs/specification/pg/subterm-graph.md`).++### New features++- **Textual syntax sugar** ([#809](https://github.com/CategoricalData/hydra/issues/809), [#811](https://github.com/CategoricalData/hydra/issues/811)): nominal construction and elimination sugar+  (`record`/`inject`/`wrap {...}`, `project`/`unwrap [...]`), applied `case` sugar, and monadic `do` blocks+  (`do either`, `do list`, `do optional`, `do effect`).+- **Source spans** ([#815](https://github.com/CategoricalData/hydra/issues/815)): the parsers track source offsets and record term spans through the new+  `hydra.core.positions` module; spans are round-trip-exempt surface trivia.+- **Parsers and printers** ([#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)): `hydra.core.parse.core` (term, type, and type scheme parser),+  parse/print for packaging, doc-comment parsing into `EntityMetadata`, and `line:col` parse errors.+  A signature-level `lazy` keyword round-trips `Parameter.isLazy` ([#800](https://github.com/CategoricalData/hydra/issues/800)),+  and raw `cases(...)` accepts the `_` default field ([#822](https://github.com/CategoricalData/hydra/issues/822)).+- **JSON** ([#776](https://github.com/CategoricalData/hydra/issues/776), [#777](https://github.com/CategoricalData/hydra/issues/777)): `JsonWriterOptions` and `printJsonWith` for configurable JSON layout,+  and `\uXXXX` escapes with surrogate pairs in the JSON parser.+- **Error printers** ([#778](https://github.com/CategoricalData/hydra/issues/778)): real printers for inference and extraction errors replace placeholder constants.+- **Spec generator** ([#723](https://github.com/CategoricalData/hydra/issues/723)): the `hydra.RegenerateSpec` driver and `bin/regenerate-spec.sh` now exist,+  and the module-reference pages under `docs/specification/` are generated by them.+  The module reference is still partial (only the primitives and four kernel type modules are covered).+  Primitive pages show named signatures (`isAlpha(char: int32) → boolean`) with Parameters and Returns entries,+  type pages list fields and variants, and headings use local names so in-page links work.+- **Build system in Hydra** ([#788](https://github.com/CategoricalData/hydra/issues/788)): the lib-pass partition (`isLibModule`, `partitionLibModules`) moves into the+  translingual `hydra.build.modules`, consumed by the Java, Scala, and Haskell drivers.+- **Bootstrap matrix** ([#769](https://github.com/CategoricalData/hydra/issues/769)): `docs/bootstrap-matrix.md` persists the N×N cross-host generation matrix.+- **Build slot tooling** ([#730](https://github.com/CategoricalData/hydra/issues/730), [#814](https://github.com/CategoricalData/hydra/issues/814)): `with-stack-slot.sh` gains a second lane, priorities, pinning, and a memory guard,+  and scripts that run bare `stack` re-exec under it.+- **CI** ([#821](https://github.com/CategoricalData/hydra/issues/821), [#700](https://github.com/CategoricalData/hydra/issues/700)): an inference-cost guard (time and peak memory) and a dedicated haskell-tests job.++### Bug fixes++- [#799](https://github.com/CategoricalData/hydra/issues/799): shadow-renaming of variables was decoupled across three layers (`unshadowVariables`,+  `analyzeFunctionTermWithGather`, the Java coder's `dedupBindings`).+- [#803](https://github.com/CategoricalData/hydra/issues/803), [#804](https://github.com/CategoricalData/hydra/issues/804), [#805](https://github.com/CategoricalData/hydra/issues/805): printed import aliases and bare names now round-trip.+- [#798](https://github.com/CategoricalData/hydra/issues/798): a `Term.variable` encodes and decodes as `{"@var": "name"}` at any JSON position.+- [#817](https://github.com/CategoricalData/hydra/issues/817): `printFloat32`/`printFloat64` for subnormals in the Common Lisp, Emacs Lisp, and Clojure hosts.+- [#779](https://github.com/CategoricalData/hydra/issues/779): the Python coder no longer breaks on nested module names.+- [#752](https://github.com/CategoricalData/hydra/issues/752): `PropertyType.required` was hardcoded to true.+- [#751](https://github.com/CategoricalData/hydra/issues/751), [#832](https://github.com/CategoricalData/hydra/issues/832), [#838](https://github.com/CategoricalData/hydra/issues/838): the SHACL serializer emits blank nodes for anonymous shape references, RDF lists for+  `sh:in`/`sh:and`/`sh:or`/`sh:xone`, definition references under `sh:node`/`sh:not`/`sh:and`/`sh:or`/`sh:xone`,+  and qualified value shapes with their counts.+- [#754](https://github.com/CategoricalData/hydra/issues/754): IRI strings are escaped in the rdf4j serializer.+- [#748](https://github.com/CategoricalData/hydra/issues/748), [#781](https://github.com/CategoricalData/hydra/issues/781): `inferInGraphContext` routes through the discharge-and-finalize tail, and+  `inferModules` seeds its graph from both universe and target modules.+- [#764](https://github.com/CategoricalData/hydra/issues/764): `refreshModule` fails loudly on dropped bindings; binding dedup and primitive shadowing are fixed.+- [#649](https://github.com/CategoricalData/hydra/issues/649): the Python coder merges a type and a term that share a module path.+- [#780](https://github.com/CategoricalData/hydra/issues/780): generated Javadoc escapes backslashes and `*/`.+- [#782](https://github.com/CategoricalData/hydra/issues/782): simple Unicode case mapping on the Common Lisp and Emacs Lisp hosts.+- [#775](https://github.com/CategoricalData/hydra/issues/775): `mapSet` is unregistered on hosts that never implemented it.+- [#289](https://github.com/CategoricalData/hydra/issues/289), [#762](https://github.com/CategoricalData/hydra/issues/762), [#801](https://github.com/CategoricalData/hydra/issues/801): stale post-rename paths in the Go overlay imports, the TypeScript bootstrap driver,+  and the Common Lisp and Emacs Lisp test loaders.+- [#741](https://github.com/CategoricalData/hydra/issues/741), [#747](https://github.com/CategoricalData/hydra/issues/747), [#757](https://github.com/CategoricalData/hydra/issues/757), [#771](https://github.com/CategoricalData/hydra/issues/771), [#787](https://github.com/CategoricalData/hydra/issues/787), [#823](https://github.com/CategoricalData/hydra/issues/823), [#831](https://github.com/CategoricalData/hydra/issues/831): sync and cold-seed fixes+  (target assembly order, `hostOverrides` immunity, overlay hashing in the freshness gate, downstream assembly after+  overlay re-apply, the generator stamp's coder-copy component).+- [#736](https://github.com/CategoricalData/hydra/issues/736): CI pins JDK 11 for the Haskell job after `ubuntu-latest` moved to JDK 25.+- [#755](https://github.com/CategoricalData/hydra/issues/755): effects fixes (Type.effect encoder arms, Python `map_list`, Emacs Lisp loading).+- [#812](https://github.com/CategoricalData/hydra/issues/812): the Clojure/Scheme `testEnv` redirect applies to generated test trees only.+- [#768](https://github.com/CategoricalData/hydra/issues/768): the cold-seed driver step fails fast when its local fallback cannot succeed.+- [#825](https://github.com/CategoricalData/hydra/issues/825): `dist/haskell/hydra-kernel` is reseeded when stale relative to `dist/json`.+- [#839](https://github.com/CategoricalData/hydra/issues/839): the assemble freshness gate refreshes a stale input digest after a rebase instead of failing, and never rewrites a current one.+- [#826](https://github.com/CategoricalData/hydra/issues/826): Lisp coders reference nullary effect primitives by call.+- [#827](https://github.com/CategoricalData/hydra/issues/827): overlay variant-order tables are checked against `model.json`.+- [#772](https://github.com/CategoricalData/hydra/issues/772), [#756](https://github.com/CategoricalData/hydra/issues/756): several silent failures in the sync scripts and vitest/Scala drivers now fail loudly.++### Improvements++- Python DSL phantom types are threaded through combinator signatures ([#731](https://github.com/CategoricalData/hydra/issues/731), [#732](https://github.com/CategoricalData/hydra/issues/732), [#818](https://github.com/CategoricalData/hydra/issues/818)).+- Hackage and PyPI batch publish sets are derived from the package registry ([#573](https://github.com/CategoricalData/hydra/issues/573), [#577](https://github.com/CategoricalData/hydra/issues/577)).+- Pre-existing namespace leftovers from the 0.18.0 rename are cleaned up in Lisp, Scala, TypeScript, and Java bootstrap+  drivers ([#767](https://github.com/CategoricalData/hydra/issues/767), [#729](https://github.com/CategoricalData/hydra/issues/729)).+- `/bootstrap`, `/sync-default`, `/test`, and the pre-push gate default to Java and Python, with Haskell opt-in+  ([#773](https://github.com/CategoricalData/hydra/issues/773)); the bootstrap demo holds the build slot only for its own `stack` calls ([#797](https://github.com/CategoricalData/hydra/issues/797)).+- `bin/sync.sh` prints per-phase timing ([#824](https://github.com/CategoricalData/hydra/issues/824)), and the CI Haskell job is split to stay within the runner time limit.+- `with-stack-slot.sh` fails fast on low disk before a build ([#789](https://github.com/CategoricalData/hydra/issues/789)).+- `bin/verify-hydra-sources.sh --dsl` runs the dual-edit guard in reverse, regenerating from the Haskell DSL twins and+  comparing with the committed JSON ([#837](https://github.com/CategoricalData/hydra/issues/837)).+- `docs/hydra-lexicon.txt` prints primitives with named parameters, matching the generated spec pages+  ([#723](https://github.com/CategoricalData/hydra/issues/723)).++### Documentation++- `docs/specification/syntax.md` gains the module-level grammar, doc comments, import aliasing, file layout,+  `@param`/`@return`, and the named-parameter primitive signature.+- The kernel README, `docs/implementation.md`, `docs/build-system.md`, and the test and primitive recipes describe the+  `.hydra` sources and the dual-edit rule.+- The hand-written primitive spec pages use the `hydra.core.lib.*` namespace.+- Recipes and READMEs document the decoder/encoder fixpoint guard ([#760](https://github.com/CategoricalData/hydra/issues/760)), keeping derived modules out of+  re-inference ([#758](https://github.com/CategoricalData/hydra/issues/758)), the hydra-ext coder testing pattern ([#699](https://github.com/CategoricalData/hydra/issues/699)), scripts with no automated caller+  ([#714](https://github.com/CategoricalData/hydra/issues/714)), overlay-versus-prune ordering ([#645](https://github.com/CategoricalData/hydra/issues/645)), the Phase 1 memory envelope ([#592](https://github.com/CategoricalData/hydra/issues/592)),+  and the Rust coder's home in `hydra-rust` ([#382](https://github.com/CategoricalData/hydra/issues/382)).++---+ ## [0.18.0] - 2026-09-29  Module-naming systematization release: every kernel and package module moves onto a uniform@@ -48,9 +186,11 @@   JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the   kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and   the Python coder (silently dropping a module's types when types and terms share a file path).-- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)):-  the module-reference pages under `docs/specification/` are now generated directly from the kernel-  (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained.+- **Specification-docs generator, kernel side** ([#723](https://github.com/CategoricalData/hydra/issues/723)):+  a new metadata-only doc coder (`generateModuleDoc`) and `hydra.markdown` model, the translingual core+  for generating the module-reference pages under `docs/specification/`. *Erratum:* the Java driver that+  `bin/regenerate-spec.sh` invokes (`hydra.RegenerateSpec`) did not ship in 0.18.0, so the pages are still+  hand-maintained; the driver is pending under #723.  ### New features @@ -58,7 +198,7 @@   suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors,   grouping) across all 9 hosts. - **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and-  `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages.+  `generateModuleDoc`, the metadata-only doc coder intended to back self-generated spec pages. - **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of   `hydra-ext` into its own first-class `hydra-rust` package. 
hydra-rdf.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-rdf-version:        0.18.0+version:        0.18.1 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@@ -46,6 +46,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.18.0+    , hydra-kernel ==0.18.1     , scientific >=0.3.7 && <0.4   default-language: Haskell2010
src/main/haskell/Hydra/Rdf/Dsl/Shacl/Model.hs view
@@ -4,6 +4,7 @@  module Hydra.Rdf.Dsl.Shacl.Model where +import qualified Hydra.Core.Dsl.Model as DslModel import qualified Hydra.Core.Errors as Errors import qualified Hydra.Core.Graph as Graph import qualified Hydra.Core.Model as Model
src/main/haskell/Hydra/Rdf/Dsl/Syntax.hs view
@@ -4,6 +4,7 @@  module Hydra.Rdf.Dsl.Syntax where +import qualified Hydra.Core.Dsl.Model as DslModel import qualified Hydra.Core.Model as Model import qualified Hydra.Core.Typed as Typed import qualified Hydra.Rdf.Syntax as Syntax
src/main/haskell/Hydra/Rdf/Shacl/Coder.hs view
@@ -107,7 +107,7 @@           forType =                   \mn -> \mx -> \t -> case (Strip.deannotateType t) of                     Model.TypeOptional v0 -> forType (Just 0) mx v0-                    Model.TypeSet v0 -> forType mn Nothing v0+                    Model.TypeSet v0 -> forType (Just 0) Nothing v0                     _ -> forTypeDefault mn mx t           forTypeDefault =                   \mn -> \mx -> \t -> Eithers.map (\_cp ->
src/main/haskell/Hydra/Rdf/ShaclRdf.hs view
@@ -20,8 +20,12 @@ import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Core.Overlay.Haskell.Lib.Math as Math import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering+import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Core.Markdown as Markdown import qualified Hydra.Core.Model as Model import qualified Hydra.Core.Packaging as Packaging@@ -48,6 +52,21 @@ import qualified Data.Scientific as Sci import Data.Void +-- | Allocate a deterministic blank node for the k-th anonymous object of a SHACL property (given by its local name) on a subject. The label is derived from the subject, the property, and the ordinal, so serialization stays pure and stable. An IRI subject is escaped to [A-Za-z0-9_] characters; a blank node subject (itself allocated here) is used as-is. Because every allocated label contains '-' and an escaped IRI never does, the labels are injective.+anonymousBlankNode :: Syntax.Resource -> String -> Int -> Syntax.Resource+anonymousBlankNode subj rel k =++      let parentKey =+              case subj of+                Syntax.ResourceIri v0 -> escapeBlankNodeLabelPart (Syntax.unIri v0)+                Syntax.ResourceBnode v0 -> Syntax.unBlankNode v0+      in (Syntax.ResourceBnode (Syntax.BlankNode (Strings.concat [+        parentKey,+        "-",+        rel,+        "-",+        (Literals.printInt32 k)])))+ -- | Create a boolean literal node booleanNode :: Bool -> Syntax.Node booleanNode b =@@ -65,7 +84,7 @@       ShaclModel.CommonConstraintClass _ -> []       ShaclModel.CommonConstraintNodeKind v0 -> [         tripleRII subj (sh "nodeKind") (nodeKindToIri v0)]-      ShaclModel.CommonConstraintProperty v0 -> Lists.concat (Lists.map (propertyRefToTriples subj) (Sets.toList v0))+      ShaclModel.CommonConstraintProperty v0 -> Lists.concat (Lists.map (\p -> propertyRefToTriples subj (Pairs.first p) (Pairs.second p)) (Lists.zip (Math.range 0 (Lists.length (Sets.toList v0))) (Sets.toList v0)))       ShaclModel.CommonConstraintMaxInclusive v0 -> [         tripleRIN subj (sh "maxInclusive") (Syntax.NodeLiteral v0)]       ShaclModel.CommonConstraintMinInclusive v0 -> [@@ -89,30 +108,15 @@       ShaclModel.CommonConstraintClosed v0 -> [         tripleRIN subj (sh "closed") (booleanNode (ShaclModel.closedIsClosed v0))]       ShaclModel.CommonConstraintHasValue v0 -> Lists.map (\n -> tripleRIN subj (sh "hasValue") n) (Sets.toList v0)-      ShaclModel.CommonConstraintIn v0 -> Lists.map (\n -> tripleRIN subj (sh "in") n) v0-      ShaclModel.CommonConstraintNode v0 -> Lists.concat (Lists.map (\ref -> (\x -> case x of-        ShaclModel.ReferenceNamed v1 -> [-          tripleRII subj (sh "node") v1]-        _ -> []) ref) (Sets.toList v0))-      ShaclModel.CommonConstraintNot v0 -> Lists.concat (Lists.map (\ref -> (\x -> case x of-        ShaclModel.ReferenceNamed v1 -> [-          tripleRII subj (sh "not") v1]-        _ -> []) ref) (Sets.toList v0))-      ShaclModel.CommonConstraintAnd v0 -> Lists.concat (Lists.map (\ref -> (\x -> case x of-        ShaclModel.ReferenceNamed v1 -> [-          tripleRII subj (sh "and") v1]-        _ -> []) ref) (Sets.toList v0))-      ShaclModel.CommonConstraintOr v0 -> Lists.concat (Lists.map (\ref -> (\x -> case x of-        ShaclModel.ReferenceNamed v1 -> [-          tripleRII subj (sh "or") v1]-        _ -> []) ref) (Sets.toList v0))-      ShaclModel.CommonConstraintXone v0 -> Lists.concat (Lists.map (\ref -> (\x -> case x of-        ShaclModel.ReferenceNamed v1 -> [-          tripleRII subj (sh "xone") v1]-        _ -> []) ref) (Sets.toList v0))+      ShaclModel.CommonConstraintIn v0 -> rdfListToTriples subj "in" v0+      ShaclModel.CommonConstraintNode v0 -> Lists.concat (Lists.map (\p -> referenceToTriples subj "node" inlineNodeShapeToTriples (Pairs.first p) (Pairs.second p)) (Lists.zip (Math.range 0 (Lists.length (Sets.toList v0))) (Sets.toList v0)))+      ShaclModel.CommonConstraintNot v0 -> Lists.concat (Lists.map (\p -> referenceToTriples subj "not" inlineShapeToTriples (Pairs.first p) (Pairs.second p)) (Lists.zip (Math.range 0 (Lists.length (Sets.toList v0))) (Sets.toList v0)))+      ShaclModel.CommonConstraintAnd v0 -> referenceListToTriples subj "and" inlineShapeToTriples (Sets.toList v0)+      ShaclModel.CommonConstraintOr v0 -> referenceListToTriples subj "or" inlineShapeToTriples (Sets.toList v0)+      ShaclModel.CommonConstraintXone v0 -> referenceListToTriples subj "xone" inlineShapeToTriples (Sets.toList v0)       ShaclModel.CommonConstraintEquals _ -> []       ShaclModel.CommonConstraintDisjoint _ -> []-      ShaclModel.CommonConstraintLanguageIn _ -> []+      ShaclModel.CommonConstraintLanguageIn v0 -> rdfListToTriples subj "languageIn" (Lists.map (\t -> stringNode (Syntax.unLanguageTag t)) (Sets.toList v0))  -- | Serialize CommonProperties to triples commonPropertiesToTriples :: Syntax.Resource -> ShaclModel.CommonProperties -> [Syntax.Triple]@@ -134,6 +138,27 @@         ShaclModel.ShapeNode v0 -> nodeShapeToTriples iri_ v0         ShaclModel.ShapeProperty v0 -> propertyShapeToTriples (iriResource iri_) v0 +-- | Escape a string for use in a blank node label: ASCII letters and digits are kept, and every other character becomes '_' followed by its decimal code point and '_'. The result is valid in N-Triples blank node labels and never contains '-'.+escapeBlankNodeLabelPart :: String -> String+escapeBlankNodeLabelPart s =+    Strings.concat (Lists.map (\c -> Logic.ifElse (Logic.or (Logic.and (Ordering.gte c 48) (Ordering.lte c 57)) (Logic.or (Logic.and (Ordering.gte c 65) (Ordering.lte c 90)) (Logic.and (Ordering.gte c 97) (Ordering.lte c 122)))) (Strings.fromList [+      c]) (Strings.concat [+      "_",+      (Literals.printInt32 c),+      "_"])) (Strings.toList s))++-- | Serialize a NodeShape to triples, given a subject resource (may be blank node), without any target+inlineNodeShapeToTriples :: Syntax.Resource -> ShaclModel.NodeShape -> [Syntax.Triple]+inlineNodeShapeToTriples subj ns_ =+    Lists.cons (tripleRII subj (rdf "type") (sh "NodeShape")) (commonPropertiesToTriples subj (ShaclModel.nodeShapeCommon ns_))++-- | Serialize a Shape to triples, given a subject resource (may be blank node), without any target+inlineShapeToTriples :: Syntax.Resource -> ShaclModel.Shape -> [Syntax.Triple]+inlineShapeToTriples subj shape =+    case shape of+      ShaclModel.ShapeNode v0 -> inlineNodeShapeToTriples subj v0+      ShaclModel.ShapeProperty v0 -> propertyShapeToTriples subj v0+ -- | Create an integer literal node integerNode :: Integer -> Syntax.Node integerNode n =@@ -171,26 +196,11 @@ -- | Serialize a NodeShape to triples nodeShapeToTriples :: Syntax.Iri -> ShaclModel.NodeShape -> [Syntax.Triple] nodeShapeToTriples iri_ ns_ =-    Lists.concat [-      [-        tripleIII iri_ (rdf "type") (sh "NodeShape"),-        (tripleIII iri_ (sh "targetClass") iri_)],-      (commonPropertiesToTriples (iriResource iri_) (ShaclModel.nodeShapeCommon ns_))]+    Lists.cons (tripleIII iri_ (sh "targetClass") iri_) (inlineNodeShapeToTriples (iriResource iri_) ns_) --- | Serialize a property shape reference (may be inline or named)-propertyRefToTriples :: Syntax.Resource -> ShaclModel.Reference ShaclModel.PropertyShape -> [Syntax.Triple]-propertyRefToTriples subj ref =-    (\x -> case x of-      ShaclModel.ReferenceNamed v0 -> [-        tripleRII subj (sh "property") v0]-      ShaclModel.ReferenceDefinition v0 ->-        let iri_ = ShaclModel.definitionIri v0-            ps = ShaclModel.definitionTarget v0-        in (Lists.concat [-          [-            tripleRII subj (sh "property") iri_],-          (propertyShapeToTriples (iriResource iri_) ps)])-      ShaclModel.ReferenceAnonymous _ -> []) ref+-- | Serialize the k-th property shape reference of a subject (may be named, anonymous, or an inline definition)+propertyRefToTriples :: Syntax.Resource -> Int -> ShaclModel.Reference ShaclModel.PropertyShape -> [Syntax.Triple]+propertyRefToTriples subj k ref = referenceToTriples subj "property" propertyShapeToTriples k ref  -- | Serialize a PropertyShapeConstraint to triples propertyShapeConstraintToTriples :: Syntax.Resource -> ShaclModel.PropertyShapeConstraint -> [Syntax.Triple]@@ -204,7 +214,13 @@       ShaclModel.PropertyShapeConstraintLessThanOrEquals _ -> []       ShaclModel.PropertyShapeConstraintUniqueLang v0 -> [         tripleRIN subj (sh "uniqueLang") (booleanNode v0)]-      ShaclModel.PropertyShapeConstraintQualifiedValueShape _ -> []+      ShaclModel.PropertyShapeConstraintQualifiedValueShape v0 -> Lists.concat [+        referenceToTriples subj "qualifiedValueShape" inlineShapeToTriples 0 (ShaclModel.qualifiedValueShapeQualifiedValueShape v0),+        [+          tripleRIN subj (sh "qualifiedMinCount") (integerNode (ShaclModel.qualifiedValueShapeQualifiedMinCount v0)),+          (tripleRIN subj (sh "qualifiedMaxCount") (integerNode (ShaclModel.qualifiedValueShapeQualifiedMaxCount v0)))],+        (Optionals.match (ShaclModel.qualifiedValueShapeQualifiedValueShapesDisjoint v0) [] (\b -> [+          tripleRIN subj (sh "qualifiedValueShapesDisjoint") (booleanNode b)]))]  -- | Serialize a PropertyShape to triples, given a subject resource (may be blank node) propertyShapeToTriples :: Syntax.Resource -> ShaclModel.PropertyShape -> [Syntax.Triple]@@ -221,6 +237,46 @@ -- | Construct an IRI in the RDF namespace rdf :: String -> Syntax.Iri rdf local = Utils.rdfIri local++-- | Serialize a list-valued SHACL property (given by its local name, e.g. sh:in) as a single triple whose object is an RDF collection: a chain of rdf:first/rdf:rest cells on deterministic blank nodes, terminated by rdf:nil. An empty list is rdf:nil itself. Cell labels use the property name suffixed with 'List', so they never collide with blank nodes allocated for the list's own members.+rdfListToTriples :: Syntax.Resource -> String -> [Syntax.Node] -> [Syntax.Triple]+rdfListToTriples subj rel nodes =++      let n = Lists.length nodes+          cell = \i -> anonymousBlankNode subj (Strings.concat2 rel "List") i+          cellNode = \i -> Logic.ifElse (Ordering.lt i n) (Utils.resourceToNode (cell i)) (iriNode (rdf "nil"))+      in (Lists.cons (tripleRIN subj (sh rel) (cellNode 0)) (Lists.concat (Lists.map (\p ->+        let i = Pairs.first p+            c = cell i+        in [+          tripleRIN c (rdf "first") (Pairs.second p),+          (tripleRIN c (rdf "rest") (cellNode (Math.add i 1)))]) (Lists.zip (Math.range 0 n) nodes))))++-- | Serialize a reference-valued SHACL property whose value is a single SHACL list of shapes (sh:and, sh:or, sh:xone): one triple whose object is the list of referenced shapes, plus the triples of any anonymous shapes.+referenceListToTriples :: Syntax.Resource -> String -> (Syntax.Resource -> t0 -> [Syntax.Triple]) -> [ShaclModel.Reference t0] -> [Syntax.Triple]+referenceListToTriples subj rel toTriples refs =++      let objs =+              Optionals.givens (Lists.map (\p -> referenceToObject subj rel toTriples (Pairs.first p) (Pairs.second p)) (Lists.zip (Math.range 0 (Lists.length refs)) refs))+      in (Lists.concat2 (rdfListToTriples subj rel (Lists.map (\o -> Pairs.first o) objs)) (Lists.concat (Lists.map (\o -> Pairs.second o) objs)))++-- | Resolve the k-th reference-valued object of a SHACL property (given by its local name) on a subject to an RDF node, together with any triples describing it. A named reference is its IRI; an anonymous reference is a fresh deterministic blank node, onto which the inline shape is serialized using the given function. An inline definition is its own IRI, onto which the inline shape is serialized.+referenceToObject :: Syntax.Resource -> String -> (Syntax.Resource -> t0 -> [t1]) -> Int -> ShaclModel.Reference t0 -> Maybe (Syntax.Node, [t1])+referenceToObject subj rel toTriples k ref =+    (\x -> case x of+      ShaclModel.ReferenceNamed v0 -> Just (iriNode v0, [])+      ShaclModel.ReferenceAnonymous v0 ->+        let b = anonymousBlankNode subj rel k+        in (Just (Utils.resourceToNode b, (toTriples b v0)))+      ShaclModel.ReferenceDefinition v0 ->+        let iri_ = ShaclModel.definitionIri v0+            target = ShaclModel.definitionTarget v0+        in (Just (iriNode iri_, (toTriples (iriResource iri_) target)))) ref++-- | Serialize the k-th reference-valued object of a SHACL property (given by its local name) on a subject, as a triple linking the subject to the referenced shape plus any triples describing it.+referenceToTriples :: Syntax.Resource -> String -> (Syntax.Resource -> t0 -> [Syntax.Triple]) -> Int -> ShaclModel.Reference t0 -> [Syntax.Triple]+referenceToTriples subj rel toTriples k ref =+    Optionals.match (referenceToObject subj rel toTriples k ref) [] (\o -> Lists.cons (tripleRIN subj (sh rel) (Pairs.first o)) (Pairs.second o))  -- | Construct an IRI in the SHACL namespace sh :: String -> Syntax.Iri