Crate owl_structural_model

Expand description

§owl-structural-model

Typed OWL 2 structural values for Rust.

owl-structural-model is a small, dependency-light model for representing the structural values of OWL 2: entities, class expressions, literals, annotations, axioms, ontology identity, and structural patches. It is intended for parsers, editors, validators, serializers, and storage adapters that need typed OWL values without taking a dependency on an RDF store or a reasoner.

The target standard is OWL 2, the current version of the W3C Web Ontology Language. This crate models a deliberately small, currently supported subset of the OWL 2 structural specification; it is not an OWL 2 parser, reasoner, or full conformance implementation, and it does not model the older OWL 1 API.

§W3C specifications

§What it provides

The crate keeps the structural layer explicit:

Entity and EntityKind represent OWL declarations.
ClassExpression and ObjectPropertyExpression represent nested OWL expressions.
OwlLiteral, Annotation, and AxiomAnnotations preserve typed values.
DataRange represents named datatypes, intersections, unions, complements, literal enumerations and facet restrictions. Constructors and deserialization check structural arity; datatype value evaluation stays outside the model.
Axiom represents the currently supported structural axiom forms.
Property axioms include all seven object-property characteristics, functional data properties, and object subproperty inclusions with either a single property expression or an ordered ObjectPropertyChain. Chains preserve repeated members and require at least two members, including on deserialization.
Object and data property axioms include equivalence, disjointness, domains, ranges, and subproperty inclusions; object properties also support inverse relationships. Datatype definitions retain their structural DataRange.
KeyProperties keeps object and data key properties separate and rejects a key with neither, including during deserialization. Axiom::has_key associates those properties with a class expression; it does not execute key reasoning.
OntologyId represents anonymous, named, and versioned ontology identity.
OntologyPatch represents a non-empty set of changes to one ontology.

It does not parse files, perform I/O, access a graph store, run a reasoner, or choose an application-specific profile. A caller can stream a document as individual axioms and retain only the bounded structural values it needs.

The structural layer is shared vocabulary for editors and reasoner adapters. Its constructors enforce local shape invariants; ontology-wide OWL 2 DL restrictions, profile membership, RDF mapping, and RDF closure execution are separate responsibilities. An RDF reasoner need not convert every input triple to a structural axiom before applying OWL-RL/RDF rules.

Property chains follow OWL 2 object subproperty axioms. All axioms expose annotations() and with_annotations() to inspect or replace axiom annotations without changing the structural operands.

§Example

use iri_rfc3987::Iri;
use owl_structural_model::{Axiom, ClassExpression, Entity};

fn iri(value: &str) -> Iri<String> {
    Iri::parse(value).expect("example IRI is valid").into()
}

let customer = Entity::class(iri("https://example.org/Customer"));
let declaration: Axiom = Axiom::declaration(customer);
let subclass: Axiom = Axiom::sub_class_of(
    ClassExpression::named(iri("https://example.org/Customer")),
    ClassExpression::named(iri("https://example.org/Party")),
);

assert!(matches!(declaration, Axiom::Declaration { .. }));
assert!(matches!(subclass, Axiom::SubClassOf { .. }));

§Validation

Constructors reject invalid structural shapes immediately. For example, equivalent classes require at least two operands. Structural errors use StructuralModelError; shared RDF constructors return rdf_structural_model::ModelError.

§Serialization

All semantic types implement Serde serialization and deserialization directly, without a JSON-specific representation. The integration suites exercise JSON and Postcard, including every supported axiom and expression variant, ontology identities, annotations and all patch operations. Nested literals retain their exact lexical form and language metadata.

Deserialization enforces the same local checks as constructors: operand counts, well-formed language tags, coherent literal datatype/facets, scoped non-empty anonymous identities, valid ontology identity combinations, and non-empty patches. This does not evaluate datatype lexical spaces or validate OWL profiles. Public enum variants can still be assembled directly; callers should use checked constructors.

Serde encodings do not implement RDF concrete syntaxes or OWL Functional-Style Syntax, and do not define canonical identity bytes or a stable storage protocol. Postcard is a test dependency, not a runtime encoding requirement.

§Shared RDF values and caller representations

OwlLiteral is a re-export of rdf_structural_model::Literal, and BlankNodeId is the shared scoped anonymous identity. Literal lexical forms remain exact; language-tag identity ignores ASCII case while serialization preserves spelling. Anonymous identities include an application-assigned scope IRI; identical local labels from different scopes are distinct. No global identifier allocation occurs.

Annotation<L, B>, AnnotationValue<L, B>, AxiomAnnotations<L, B>, Axiom<L, B>, OntologyPatch<L, B> and OntologyPatchOperation<L, B> accept caller-owned literal and anonymous representations. AnnotationSubject<B> and DataRange<L>/FacetRestriction<L> propagate the corresponding representation. Defaults are the shared RDF literal and scoped blank node. Named OWL entities and property IRIs remain validated Iri<String> values. Construction imposes no serialization or cloning requirements on caller-supplied payloads; Serde and other derived traits are conditional on their corresponding traits.

The shared literal default also represents RDF 1.2 directional language strings. Representability does not imply OWL 2 profile membership or inference support. Callers supplying custom values own their validation and semantic contracts; serialized payloads retain their selected type without JSON intermediates.

This release replaces the old literal enum and unscoped label shape directly. Use LanguageTag::try_new before OwlLiteral::language_tagged, handle the result of OwlLiteral::typed, and supply BlankNodeId::try_new(scope, label) for anonymous annotations. Give generic constructors a result type, such as let axiom: Axiom = Axiom::declaration(entity), when inputs do not determine the literal and anonymous types.

§Scope and memory

The crate models individual structural values and explicit, caller-owned patches. It does not promise that an entire ontology fits in memory. A parser or application handling an unbounded source should stream axioms and apply its own explicit limits or persistence strategy.

rdf-structural-model — shared RDF literals, scoped blank nodes, triples/quads and borrowed values.
iri-rfc3987 — typed IRI parsing, validation, and resolution.
iri-namespace — validated RDF namespaces, prefixes, and CURIEs.
rdf-winnow — reusable RDF lexical parsers built on winnow.
shacl-structural-model — typed structural values for SHACL shapes.
sparql-results — async streaming SPARQL Results XML and JSON serialization.

§License

Licensed under either of:

Apache License, Version 2.0
MIT License

at your option. Typed OWL 2 structural values without an RDF-store dependency.

Structs§

Annotation: An OWL annotation.
AxiomAnnotations: Axiom annotations attached to one structural axiom.
BlankNodeId: An abstract blank-node identity, independent of a concrete syntax label.
Entity: An OWL entity declaration target.
FacetRestriction: A datatype facet IRI paired with an exact literal restriction value.
KeyProperties: The object and data properties identifying instances in one HasKey axiom.
ObjectPropertyChain: An ordered chain of at least two object property expressions.
OntologyId: OWL ontology identity: optional ontology IRI plus optional version IRI.
OntologyPatch: A non-empty collection of structural changes for one ontology identity.
OwlLiteral: A standard RDF literal with an exact UTF-8 lexical form.

Enums§

AnnotationSubject: Subject of an OWL annotation assertion.
AnnotationValue: A value that can appear in an OWL annotation.
Axiom: An OWL structural axiom.
ClassExpression: An OWL class expression.
DataRange: A unary OWL 2 data range, independent of any datatype evaluator or RDF store.
EntityKind: Kind of OWL entity.
ObjectPropertyExpression: An OWL object property expression.
OntologyPatchOperation: One structural ontology patch operation.
StructuralModelError: A structural value failed an invariant at construction time.
SubObjectPropertyExpression: The subproperty operand of an OWL 2 SubObjectPropertyOf axiom.

Type Aliases§

OntologyIdentity: Alias emphasizing that this value is metadata rather than a document.