@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/src/LanguageTag.ts

@@ -0,0 +1,98 @@
+/**
+ * BCP 47 language tags, as RDF 1.2 requires them: well-formedness (BCP 47
+ * §2.2.9, the `Language-Tag` ABNF of §2.1), the canonical lower-case form
+ * RDF terms carry, and a `Schema` for validating tags at a boundary.
+ *
+ * The syntax packages keep their grammar's own `LANGTAG` production
+ * (`[a-zA-Z]+ ('-' [a-zA-Z0-9]+)*`), which the W3C suites test and which is
+ * looser than BCP 47; use `isWellFormed` where full BCP 47 is wanted.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from 'effect/Schema';
+
+const ALNUM = '[a-z0-9]';
+// language = 2*3ALPHA ["-" extlang] / 4ALPHA / 5*8ALPHA; extlang = 3ALPHA *2("-" 3ALPHA)
+const LANGUAGE = '(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4,8})';
+const SCRIPT = '(?:-[a-z]{4})?';
+const REGION = '(?:-(?:[a-z]{2}|[0-9]{3}))?';
+const VARIANTS = `(?:-(?:${ALNUM}{5,8}|[0-9]${ALNUM}{3}))*`;
+// singleton = alphanum except "x"
+const EXTENSIONS = `(?:-[0-9a-wy-z](?:-${ALNUM}{2,8})+)*`;
+const PRIVATE_USE = `x(?:-${ALNUM}{1,8})+`;
+const LANGTAG = `${LANGUAGE}${SCRIPT}${REGION}${VARIANTS}${EXTENSIONS}(?:-${PRIVATE_USE})?`;
+
+// The grandfathered tags (BCP 47 §2.1, `irregular` and `regular`).
+const GRANDFATHERED = [
+  'en-gb-oed',
+  'i-ami',
+  'i-bnn',
+  'i-default',
+  'i-enochian',
+  'i-hak',
+  'i-klingon',
+  'i-lux',
+  'i-mingo',
+  'i-navajo',
+  'i-pwn',
+  'i-tao',
+  'i-tay',
+  'i-tsu',
+  'sgn-be-fr',
+  'sgn-be-nl',
+  'sgn-ch-de',
+  'art-lojban',
+  'cel-gaulish',
+  'no-bok',
+  'no-nyn',
+  'zh-guoyu',
+  'zh-hakka',
+  'zh-min',
+  'zh-min-nan',
+  'zh-xiang',
+].join('|');
+
+const WELL_FORMED = new RegExp(`^(?:${LANGTAG}|${PRIVATE_USE}|${GRANDFATHERED})$`, 'i');
+
+/**
+ * Whether a string is a well-formed BCP 47 language tag (§2.2.9): it matches
+ * the `Language-Tag` ABNF, case-insensitively. Registry validity (known
+ * subtags, no duplicate variants or extensions) is not checked.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+export const isWellFormed = (tag: string): boolean => WELL_FORMED.test(tag);
+
+/**
+ * The form a language tag takes in an RDF term: lower case (RDF 1.2 compares
+ * tags case-insensitively, and `Term.literal` lower-cases them).
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+export const normalize = (tag: string): string => tag.toLowerCase();
+
+/**
+ * Schema of a well-formed BCP 47 language tag (`isWellFormed`): a string,
+ * decoded unchanged.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export const LanguageTagSchema: Schema.String = Schema.String.check(
+  Schema.makeFilter((tag: string) => isWellFormed(tag), {
+    identifier: 'isLanguageTag',
+    title: 'Language tag',
+    description: 'A well-formed BCP 47 language tag.',
+    expected: 'a BCP 47 language tag',
+  }),
+).annotate({ identifier: 'LanguageTag' });
+
+/**
+ * The type `LanguageTagSchema` decodes to: a string.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export type LanguageTagSchema = typeof LanguageTagSchema.Type;

package/src/Namespace.ts

@@ -0,0 +1,100 @@
+/**
+ * Namespaces and strongly-typed vocabularies.
+ *
+ * ```ts
+ * import { Namespace } from "@thomasfosterau/effect-rdf"
+ *
+ * const ex = Namespace.make("http://example.org/")
+ * ex("alice") // NamedNode<"http://example.org/alice">
+ *
+ * const foaf = Namespace.vocabulary("http://xmlns.com/foaf/0.1/", ["name", "knows"])
+ * foaf.name // NamedNode<"http://xmlns.com/foaf/0.1/name">
+ * ```
+ *
+ * @since 0.1.0
+ */
+import { NamedNode } from './Term.ts';
+import * as MutableHashMap from 'effect/MutableHashMap';
+import * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+
+/** Whether `node` is the IRI `iri`, with the IRI's type. */
+const hasIri = <const Iri extends string>(node: NamedNode, iri: Iri): node is NamedNode<Iri> =>
+  node.value === iri;
+
+/**
+ * A function that mints IRIs within a namespace.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Namespace<Base extends string> {
+  <const Local extends string>(local: Local): NamedNode<`${Base}${Local}`>;
+  readonly base: Base;
+  readonly node: NamedNode<Base>;
+  /** Whether an IRI belongs to this namespace. */
+  readonly contains: (iri: string | NamedNode) => boolean;
+  /** The local part of an IRI within this namespace, if it belongs to it. */
+  readonly localName: (iri: string | NamedNode) => string | undefined;
+}
+
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+export const make = <const Base extends string>(base: Base): Namespace<Base> => {
+  const cache = MutableHashMap.empty<string, NamedNode>();
+  const ns = <const Local extends string>(local: Local): NamedNode<`${Base}${Local}`> => {
+    const iri: `${Base}${Local}` = `${base}${local}`;
+    return Option.getOrElse(
+      Option.filter(MutableHashMap.get(cache, local), (node) => hasIri(node, iri)),
+      () => {
+        const node = new NamedNode(iri);
+        MutableHashMap.set(cache, local, node);
+        return node;
+      },
+    );
+  };
+  const contains = (iri: string | NamedNode) =>
+    (Predicate.isString(iri) ? iri : iri.value).startsWith(base);
+  return Object.assign(ns, {
+    base,
+    node: new NamedNode(base),
+    contains,
+    localName: (iri: string | NamedNode) => {
+      const value = Predicate.isString(iri) ? iri : iri.value;
+      return value.startsWith(base) ? value.slice(base.length) : undefined;
+    },
+  });
+};
+
+/**
+ * A closed vocabulary: a namespace plus a fixed set of typed terms.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Vocabulary<Base extends string, Terms extends string> = Namespace<Base> & {
+  readonly [K in Terms]: NamedNode<`${Base}${K}`>;
+} & { readonly terms: ReadonlyArray<Terms> };
+
+/**
+ * Creates a closed vocabulary with statically-known terms.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const vocabulary = <const Base extends string, const Terms extends string>(
+  base: Base,
+  terms: ReadonlyArray<Terms>,
+): Vocabulary<Base, Terms> => {
+  const ns = make(base);
+  const props: PropertyDescriptorMap = {
+    terms: { value: terms, enumerable: false },
+  };
+  terms.forEach((term) => {
+    props[term] = { value: ns(term), enumerable: true };
+  });
+  // SAFETY: `props` defines one property per term in `Terms`.
+  return Object.defineProperties(ns, props) as Vocabulary<Base, Terms>;
+};

package/src/PrefixMap.ts

@@ -0,0 +1,117 @@
+/**
+ * Immutable prefix ↔ namespace mappings used to expand and compact IRIs.
+ *
+ * @since 0.1.0
+ */
+import * as Option from 'effect/Option';
+import { NamedNode } from './Term.ts';
+import { commonPrefixes } from './Vocab.ts';
+import * as Predicate from 'effect/Predicate';
+import * as Record from 'effect/Record';
+
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface PrefixMap {
+  readonly prefixes: ReadonlyMap<string, string>;
+}
+
+/**
+ * The `prefixes` of a prefix map: a native `ReadonlyMap`, as the public
+ * field is typed; a later entry for a prefix replaces an earlier one.
+ */
+function prefixMap(entries: Iterable<readonly [string, string]>): ReadonlyMap<string, string> {
+  return new Map(entries);
+}
+
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+export const empty: PrefixMap = { prefixes: prefixMap([]) };
+
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+export const make = (
+  prefixes: Record.ReadonlyRecord<string, string> | Iterable<readonly [string, string]>,
+): PrefixMap => ({
+  prefixes: prefixMap(Symbol.iterator in prefixes ? prefixes : Record.toEntries(prefixes)),
+});
+
+/**
+ * A prefix map containing `rdf`, `rdfs`, `xsd` and `owl`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const common: PrefixMap = make(commonPrefixes);
+
+/**
+ * @since 0.1.0
+ * @category combinators
+ */
+export const set = (self: PrefixMap, prefix: string, namespace: string): PrefixMap => {
+  return { prefixes: prefixMap([...self.prefixes, [prefix, namespace]]) };
+};
+
+/**
+ * Merges two prefix maps; entries in `that` win.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export const merge = (self: PrefixMap, that: PrefixMap): PrefixMap => ({
+  prefixes: prefixMap([...self.prefixes, ...that.prefixes]),
+});
+
+/**
+ * @since 0.1.0
+ * @category getters
+ */
+export const get = (self: PrefixMap, prefix: string): Option.Option<string> =>
+  Option.fromNullishOr(self.prefixes.get(prefix));
+
+/**
+ * Expands a prefixed name (`prefix:local`) to an IRI.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export const expand = (self: PrefixMap, curie: string): Option.Option<NamedNode> => {
+  const i = curie.indexOf(':');
+  if (i === -1) return Option.none();
+  const ns = self.prefixes.get(curie.slice(0, i));
+  return ns === undefined ? Option.none() : Option.some(new NamedNode(ns + curie.slice(i + 1)));
+};
+
+const PN_LOCAL_SIMPLE =
+  /^(?:[A-Za-z0-9_À-�:]|%[0-9A-Fa-f]{2})(?:(?:[A-Za-z0-9_\-.·À-�:]|%[0-9A-Fa-f]{2})*(?:[A-Za-z0-9_\-·À-�:]|%[0-9A-Fa-f]{2}))?$/;
+
+/**
+ * Compacts an IRI to `[prefix, local]` using the longest matching namespace,
+ * if the local part is a valid Turtle/SPARQL `PN_LOCAL` without escapes.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export const compact = (
+  self: PrefixMap,
+  iri: string | NamedNode,
+): Option.Option<readonly [string, string]> => {
+  const value = Predicate.isString(iri) ? iri : iri.value;
+  let best: Option.Option<readonly [string, string]> = Option.none();
+  let bestLength = -1;
+  self.prefixes.forEach((ns, prefix) => {
+    if (ns.length > bestLength && value.startsWith(ns)) {
+      const local = value.slice(ns.length);
+      if (local === '' || PN_LOCAL_SIMPLE.test(local)) {
+        best = Option.some([prefix, local]);
+        bestLength = ns.length;
+      }
+    }
+  });
+  return best;
+};

package/src/RdfJs.ts

@@ -0,0 +1,146 @@
+/**
+ * Conversions to and from the RDF/JS data model
+ * (https://rdf.js.org/data-model-spec/), for interoperability with the wider
+ * JavaScript RDF ecosystem. No RDF/JS packages are required: the interfaces
+ * below are structural.
+ *
+ * @since 0.1.0
+ */
+import * as Match from 'effect/Match';
+import * as Term from './Term.ts';
+
+/**
+ * A structural RDF/JS term.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RdfJsTerm =
+  | { readonly termType: 'NamedNode'; readonly value: string }
+  | { readonly termType: 'BlankNode'; readonly value: string }
+  | {
+      readonly termType: 'Literal';
+      readonly value: string;
+      readonly language: string;
+      readonly direction?: 'ltr' | 'rtl' | '' | null | undefined;
+      readonly datatype: { readonly termType: 'NamedNode'; readonly value: string };
+    }
+  | { readonly termType: 'Variable'; readonly value: string }
+  | { readonly termType: 'DefaultGraph'; readonly value: '' }
+  | RdfJsQuad;
+
+/**
+ * A structural RDF/JS quad (also used for quoted triples).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RdfJsQuad {
+  readonly termType: 'Quad';
+  readonly value: '';
+  readonly subject: RdfJsTerm;
+  readonly predicate: RdfJsTerm;
+  readonly object: RdfJsTerm;
+  readonly graph: RdfJsTerm;
+}
+
+// Built once: `fromTerm` runs for every term of every quad converted.
+const fromTermMatch: (term: RdfJsTerm) => Term.Term = Match.type<RdfJsTerm>().pipe(
+  Match.withReturnType<Term.Term>(),
+  Match.when({ termType: 'NamedNode' }, (term) => new Term.NamedNode(term.value)),
+  Match.when({ termType: 'BlankNode' }, (term) => new Term.BlankNode(term.value)),
+  Match.when({ termType: 'Literal' }, (term) =>
+    term.language !== ''
+      ? Term.literal(term.value, {
+          language: term.language,
+          direction:
+            term.direction === 'ltr' || term.direction === 'rtl' ? term.direction : undefined,
+        })
+      : Term.literal(term.value, new Term.NamedNode(term.datatype.value)),
+  ),
+  Match.when({ termType: 'Variable' }, (term) => new Term.Variable(term.value)),
+  Match.when({ termType: 'DefaultGraph' }, () => Term.defaultGraph),
+  // SAFETY: an RDF/JS quad term's components are a subject, a predicate and an object.
+  Match.when(
+    { termType: 'Quad' },
+    (term) =>
+      new Term.Triple(
+        fromTerm(term.subject) as Term.Subject,
+        fromTerm(term.predicate) as Term.Predicate,
+        fromTerm(term.object) as Term.Object,
+      ),
+  ),
+  Match.exhaustive,
+);
+
+/**
+ * Converts an RDF/JS term. Quads appearing as terms become triple terms.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export const fromTerm = (term: RdfJsTerm): Term.Term => fromTermMatch(term);
+
+/**
+ * Converts an RDF/JS quad to a `Quad`.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+// SAFETY: an RDF/JS quad's components are a subject, a predicate, an object and a graph.
+export const fromQuad = (quad: RdfJsQuad): Term.Quad =>
+  new Term.Quad(
+    fromTerm(quad.subject) as Term.Subject,
+    fromTerm(quad.predicate) as Term.Predicate,
+    fromTerm(quad.object) as Term.Object,
+    fromTerm(quad.graph) as Term.Graph,
+  );
+
+// Built once: `toTerm` runs for every term of every quad converted.
+const toTermMatch: (term: Term.Term) => RdfJsTerm = Match.type<Term.Term>().pipe(
+  Match.withReturnType<RdfJsTerm>(),
+  Match.tag('NamedNode', 'BlankNode', 'Variable', (term) => ({
+    termType: term._tag,
+    value: term.value,
+  })),
+  Match.tag('DefaultGraph', () => ({ termType: 'DefaultGraph', value: '' })),
+  Match.tag('Literal', (term) => ({
+    termType: 'Literal',
+    value: term.value,
+    language: term.language,
+    direction: term.direction ?? '',
+    datatype: { termType: 'NamedNode', value: term.datatype.value },
+  })),
+  Match.tag('Triple', (term) => ({
+    termType: 'Quad',
+    value: '',
+    subject: toTerm(term.subject),
+    predicate: toTerm(term.predicate),
+    object: toTerm(term.object),
+    graph: { termType: 'DefaultGraph', value: '' },
+  })),
+  Match.exhaustive,
+);
+
+/**
+ * Converts a term to a plain RDF/JS term object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export const toTerm = (term: Term.Term): RdfJsTerm => toTermMatch(term);
+
+/**
+ * Converts a quad to a plain RDF/JS quad object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export const toQuad = (quad: Term.Quad): RdfJsQuad => ({
+  termType: 'Quad',
+  value: '',
+  subject: toTerm(quad.subject),
+  predicate: toTerm(quad.predicate),
+  object: toTerm(quad.object),
+  graph: toTerm(quad.graph),
+});

package/src/Rdfs.ts

@@ -0,0 +1,241 @@
+/**
+ * RDF Schema: class and property hierarchies, and RDFS entailment.
+ *
+ * @since 0.1.0
+ */
+import * as Dataset from './Dataset.ts';
+import * as Term from './Term.ts';
+import { rdf, rdfs } from './Vocab.ts';
+import * as Arr from 'effect/Array';
+import * as MutableHashMap from 'effect/MutableHashMap';
+import * as Option from 'effect/Option';
+import { loop } from './internal/loop.ts';
+
+const transitiveClosure = (
+  self: Dataset.Dataset,
+  start: Term.Object,
+  property: Term.NamedNode,
+  direction: 'up' | 'down',
+): ReadonlyArray<Term.Object> => {
+  const seen = MutableHashMap.empty<string, Term.Object>();
+  const stack: Array<Term.Object> = [start];
+  // Depth-first, with an explicit stack: hierarchies can be deep
+  loop(() => {
+    const node = stack.pop();
+    if (node === undefined) return false;
+    const next: ReadonlyArray<Term.Object> =
+      direction === 'up'
+        ? Term.isLiteral(node)
+          ? []
+          : Dataset.objectsOf(self, node, property)
+        : Dataset.subjectsOf(self, property, node);
+    next.forEach((n) => {
+      if (!MutableHashMap.has(seen, n.key) && n.key !== start.key) {
+        MutableHashMap.set(seen, n.key, n);
+        stack.push(n);
+      }
+    });
+    return true;
+  });
+  return Arr.fromIterable(MutableHashMap.values(seen));
+};
+
+/**
+ * All (transitive) superclasses of a class, excluding the class itself.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const superClasses = (
+  self: Dataset.Dataset,
+  cls: Term.Resource,
+): ReadonlyArray<Term.Object> => transitiveClosure(self, cls, rdfs.subClassOf, 'up');
+
+/**
+ * All (transitive) subclasses of a class, excluding the class itself.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const subClasses = (self: Dataset.Dataset, cls: Term.Resource): ReadonlyArray<Term.Object> =>
+  transitiveClosure(self, cls, rdfs.subClassOf, 'down');
+
+/**
+ * All (transitive) superproperties of a property, excluding itself.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const superProperties = (
+  self: Dataset.Dataset,
+  property: Term.Resource,
+): ReadonlyArray<Term.Object> => transitiveClosure(self, property, rdfs.subPropertyOf, 'up');
+
+/**
+ * All (transitive) subproperties of a property, excluding itself.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const subProperties = (
+  self: Dataset.Dataset,
+  property: Term.Resource,
+): ReadonlyArray<Term.Object> => transitiveClosure(self, property, rdfs.subPropertyOf, 'down');
+
+/**
+ * The asserted types (`rdf:type` values) of a resource.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const types = (self: Dataset.Dataset, resource: Term.Subject): ReadonlyArray<Term.Object> =>
+  Dataset.objectsOf(self, resource, rdf.type);
+
+/**
+ * Whether `resource` is an instance of `cls`, taking `rdfs:subClassOf` into
+ * account.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const isInstanceOf = (
+  self: Dataset.Dataset,
+  resource: Term.Subject,
+  cls: Term.Resource,
+): boolean => {
+  const asserted = types(self, resource);
+  if (asserted.some((t) => t.key === cls.key)) return true;
+  return asserted.some(
+    (t) =>
+      !Term.isLiteral(t) &&
+      transitiveClosure(self, t, rdfs.subClassOf, 'up').some((s) => s.key === cls.key),
+  );
+};
+
+/**
+ * All instances of a class, including instances of its subclasses.
+ *
+ * @since 0.1.0
+ * @category hierarchy
+ */
+export const instancesOf = (
+  self: Dataset.Dataset,
+  cls: Term.Resource,
+): ReadonlyArray<Term.Subject> => {
+  const classes = [cls, ...subClasses(self, cls)];
+  const out = MutableHashMap.empty<string, Term.Subject>();
+  classes.forEach((c) =>
+    Dataset.subjectsOf(self, rdf.type, c).forEach((s) => {
+      MutableHashMap.set(out, s.key, s);
+    }),
+  );
+  return Arr.fromIterable(MutableHashMap.values(out));
+};
+
+/**
+ * Options for RDFS entailment.
+ *
+ * @since 0.1.0
+ * @category entailment
+ */
+export interface EntailmentOptions {
+  /**
+   * Include the axiomatic and "every resource is an rdfs:Resource" style
+   * triples (rules rdfs4a/4b, rdfs8, rdfs10, rdfs12, rdfs13, rdf1). These
+   * produce many uninteresting triples; disabled by default.
+   */
+  readonly full?: boolean;
+}
+
+/**
+ * Computes the RDFS closure of the default graph (or every graph
+ * independently) by forward chaining the RDFS entailment rules to a fixpoint.
+ *
+ * Implemented rules: rdfs2 (domain), rdfs3 (range), rdfs5 (subPropertyOf
+ * transitivity), rdfs7 (subproperty inheritance), rdfs9 (type inheritance),
+ * rdfs11 (subClassOf transitivity), and — when `full` is set — rdf1, rdfs4a,
+ * rdfs4b, rdfs6, rdfs8, rdfs10, rdfs12 and rdfs13.
+ *
+ * @since 0.1.0
+ * @category entailment
+ */
+export const closure = (
+  self: Dataset.Dataset,
+  options: EntailmentOptions = {},
+): Dataset.Dataset => {
+  return Arr.reduce(Dataset.graphs(self), self, (result, graph) =>
+    Dataset.union(result, closeGraph(Dataset.graph(self, graph), graph, options.full === true)),
+  );
+};
+
+const asSubject = (o: Term.Object): Option.Option<Term.Subject> =>
+  Term.isLiteral(o) ? Option.none() : Option.some(o);
+
+const closeGraph = (input: Dataset.Dataset, graph: Term.Graph, full: boolean): Dataset.Dataset => {
+  let ds = input;
+  const q = (s: Term.Subject, p: Term.Predicate, o: Term.Object) => new Term.Quad(s, p, o, graph);
+  // Apply the rules until a round adds nothing
+  loop(() => {
+    const before = ds.size;
+    ds = Dataset.mutate(ds, (b) => {
+      const add = (s: Term.Subject, p: Term.Predicate, o: Term.Object) => {
+        b.add(q(s, p, o));
+      };
+      const addFrom = (s: Option.Option<Term.Subject>, p: Term.Predicate, o: Term.Object) => {
+        if (Option.isSome(s)) add(s.value, p, o);
+      };
+      const all = Array.from(ds);
+      all.forEach((t) => {
+        const { subject: s, predicate: p, object: o } = t;
+        const os = asSubject(o);
+        if (full) {
+          add(p, rdf.type, rdf.Property);
+          add(s, rdf.type, rdfs.Resource);
+          addFrom(os, rdf.type, rdfs.Resource);
+        }
+        // rdfs2 / rdfs3
+        Dataset.objectsOf(ds, p, rdfs.domain, graph).forEach((d) => add(s, rdf.type, d));
+        Dataset.objectsOf(ds, p, rdfs.range, graph).forEach((r) => addFrom(os, rdf.type, r));
+        // rdfs7
+        Dataset.objectsOf(ds, p, rdfs.subPropertyOf, graph).forEach((sp) => {
+          if (Term.isNamedNode(sp)) add(s, sp, o);
+        });
+        if (p.value === rdfs.subPropertyOf.value) {
+          // rdfs5
+          if (Option.isSome(os))
+            Dataset.objectsOf(ds, os.value, rdfs.subPropertyOf, graph).forEach((x) =>
+              add(s, rdfs.subPropertyOf, x),
+            );
+        } else if (p.value === rdfs.subClassOf.value) {
+          // rdfs11
+          if (Option.isSome(os))
+            Dataset.objectsOf(ds, os.value, rdfs.subClassOf, graph).forEach((x) =>
+              add(s, rdfs.subClassOf, x),
+            );
+        } else if (p.value === rdf.type.value) {
+          // rdfs9
+          if (Option.isSome(os))
+            Dataset.objectsOf(ds, os.value, rdfs.subClassOf, graph).forEach((x) =>
+              add(s, rdf.type, x),
+            );
+          if (full) {
+            if (o.key === rdf.Property.key) {
+              // SAFETY: a subject is also a valid object.
+              add(s, rdfs.subPropertyOf, s); // rdfs6
+            }
+            if (o.key === rdfs.Class.key) {
+              add(s, rdfs.subClassOf, rdfs.Resource); // rdfs8
+              // SAFETY: a subject is also a valid object.
+              add(s, rdfs.subClassOf, s); // rdfs10
+            }
+            if (o.key === rdfs.ContainerMembershipProperty.key)
+              add(s, rdfs.subPropertyOf, rdfs.member); // rdfs12
+            if (o.key === rdfs.Datatype.key) add(s, rdfs.subClassOf, rdfs.Literal); // rdfs13
+          }
+        }
+      });
+    });
+    return ds.size !== before;
+  });
+  return ds;
+};