eyeling 1.5.33 → 1.5.35

package/examples/output/rdf-list.n3

@@ -0,0 +1,31 @@
+@prefix : <http://example.org/ns#> .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :result :is true .
+# It holds because the following instance of the rule body is provable:
+#   :X :val (1 2) .
+#   (1 2) :head 1 .
+#   (1 2) :tail (2) .
+#   1 log:equalTo 1 .
+#   (2) log:equalTo (2) .
+# via the schematic forward rule:
+#   {
+#     ?X :val ?Y .
+#     ?Y :head ?H .
+#     ?Y :tail ?T .
+#     ?H log:equalTo 1 .
+#     ?T log:equalTo (2) .
+#   } => {
+#     :result :is true .
+#   } .
+# with substitution (on rule variables):
+#   ?H = 1
+#   ?T = (2)
+#   ?X = :X
+#   ?Y = (1 2)
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:result :is true .
+

package/examples/rdf-list.n3

@@ -0,0 +1,22 @@
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix : <http://example.org/ns#> .
+
+:X :val (1 2).
+
+{ ?X :head ?Y } <= { ?X list:first ?Y }.
+{ ?X :tail ?Y } <= { ?X list:rest ?Y} .
+
+{ 
+  ?X :val ?Y.
+  ?Y :head ?H .
+  ?Y :tail ?T .
+
+  ?H log:equalTo 1.
+  ?T log:equalTo (2).
+}
+=>
+{
+  :result :is true.
+}.

package/eyeling.js

@@ -1867,91 +1867,6 @@ function termToJsStringDecoded(t) {
   return stripQuotes(lex);
 }
 
-function _jsonPointerUnescape(seg) {
-  // RFC6901: ~1 -> '/', ~0 -> '~'
-  // Any other '~' escape is invalid.
-  let out = "";
-  for (let i = 0; i < seg.length; i++) {
-    const c = seg[i];
-    if (c !== "~") { out += c; continue; }
-    if (i + 1 >= seg.length) return null;
-    const n = seg[i + 1];
-    if (n === "0") out += "~";
-    else if (n === "1") out += "/";
-    else return null;
-    i++;
-  }
-  return out;
-}
-
-function _jsonToTerm(v) {
-  if (v === null) return makeStringLiteral("null");
-  if (typeof v === "string") return makeStringLiteral(v);
-  if (typeof v === "number") return new Literal(String(v));
-  if (typeof v === "boolean") return new Literal(v ? "true" : "false");
-  if (Array.isArray(v)) return new ListTerm(v.map(_jsonToTerm));
-  if (typeof v === "object") return makeStringLiteral(JSON.stringify(v));
-  return null;
-}
-
-function _jsonPointerLookup(jsonText, pointer) {
-  // Support URI fragment form "#/a/b" (percent-decoded) as well.
-  let ptr = pointer;
-  if (ptr.startsWith("#")) {
-    try { ptr = decodeURIComponent(ptr.slice(1)); } catch (e) { return null; }
-  }
-
-  // Cache per JSON document
-  let entry = jsonPointerCache.get(jsonText);
-  if (!entry) {
-    let parsed = null;
-    try { parsed = JSON.parse(jsonText); } catch (e) { parsed = null; }
-    entry = { parsed, ptrCache: new Map() };
-    jsonPointerCache.set(jsonText, entry);
-  }
-  if (entry.parsed === null) return null;
-
-  // Cache per pointer within this doc
-  if (entry.ptrCache.has(ptr)) return entry.ptrCache.get(ptr);
-
-  let cur = entry.parsed;
-
-  if (ptr === "") {
-    const t = _jsonToTerm(cur);
-    entry.ptrCache.set(ptr, t);
-    return t;
-  }
-  if (!ptr.startsWith("/")) { entry.ptrCache.set(ptr, null); return null; }
-
-  const parts = ptr.split("/").slice(1);
-  for (const raw of parts) {
-    const seg = _jsonPointerUnescape(raw);
-    if (seg === null) { entry.ptrCache.set(ptr, null); return null; }
-
-    if (Array.isArray(cur)) {
-      // JSON Pointer uses array indices as decimal strings
-      if (!/^(0|[1-9]\d*)$/.test(seg)) { entry.ptrCache.set(ptr, null); return null; }
-      const idx = Number(seg);
-      if (!Number.isFinite(idx) || idx < 0 || idx >= cur.length) { entry.ptrCache.set(ptr, null); return null; }
-      cur = cur[idx];
-      continue;
-    }
-
-    if (cur !== null && typeof cur === "object") {
-      if (!Object.prototype.hasOwnProperty.call(cur, seg)) { entry.ptrCache.set(ptr, null); return null; }
-      cur = cur[seg];
-      continue;
-    }
-
-    entry.ptrCache.set(ptr, null);
-    return null;
-  }
-
-  const out = _jsonToTerm(cur);
-  entry.ptrCache.set(ptr, out);
-  return out;
-}
-
 function jsonPointerUnescape(seg) {
   // RFC6901: ~1 -> '/', ~0 -> '~'
   let out = "";
@@ -3036,6 +2951,40 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return [];
   }
 
+  // rdf:first (alias of list:first)
+  // Schema: $s+ rdf:first $o-
+  if (g.p instanceof Iri && g.p.value === RDF_NS + "first") {
+    if (!(g.s instanceof ListTerm)) return [];
+    if (!g.s.elems.length) return [];
+    const first = g.s.elems[0];
+    const s2 = unifyTerm(g.o, first, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // rdf:rest (alias of list:rest)
+  // Schema: $s+ rdf:rest $o-
+  if (g.p instanceof Iri && g.p.value === RDF_NS + "rest") {
+    // Closed list: (a b c) -> (b c)
+    if (g.s instanceof ListTerm) {
+      if (!g.s.elems.length) return [];
+      const rest = new ListTerm(g.s.elems.slice(1));
+      const s2 = unifyTerm(g.o, rest, subst);
+      return s2 !== null ? [s2] : [];
+    }
+    // Open list: (a b ... ?T) -> (b ... ?T)
+    if (g.s instanceof OpenListTerm) {
+      if (!g.s.prefix.length) return [];
+      if (g.s.prefix.length === 1) {
+        const s2 = unifyTerm(g.o, new Var(g.s.tailVar), subst);
+        return s2 !== null ? [s2] : [];
+      }
+      const rest = new OpenListTerm(g.s.prefix.slice(1), g.s.tailVar);
+      const s2 = unifyTerm(g.o, rest, subst);
+      return s2 !== null ? [s2] : [];
+    }
+    return [];
+  }
+
   // list:iterate
   // true iff $s is a list and $o is a list (index value),
   // where index is a valid 0-based index into $s and value is the element at that index.
@@ -3840,28 +3789,28 @@ function listHasTriple(list, tr) {
 //
 // This is semantics-preserving for the ongoing proof state.
 
-function _gcCollectVarsInTerm(t, out) {
+function gcCollectVarsInTerm(t, out) {
   if (t instanceof Var) { out.add(t.name); return; }
-  if (t instanceof ListTerm) { for (const e of t.elems) _gcCollectVarsInTerm(e, out); return; }
+  if (t instanceof ListTerm) { for (const e of t.elems) gcCollectVarsInTerm(e, out); return; }
   if (t instanceof OpenListTerm) {
-    for (const e of t.prefix) _gcCollectVarsInTerm(e, out);
+    for (const e of t.prefix) gcCollectVarsInTerm(e, out);
     out.add(t.tailVar);
     return;
   }
-  if (t instanceof FormulaTerm) { for (const tr of t.triples) _gcCollectVarsInTriple(tr, out); return; }
+  if (t instanceof FormulaTerm) { for (const tr of t.triples) gcCollectVarsInTriple(tr, out); return; }
 }
 
-function _gcCollectVarsInTriple(tr, out) {
-  _gcCollectVarsInTerm(tr.s, out);
-  _gcCollectVarsInTerm(tr.p, out);
-  _gcCollectVarsInTerm(tr.o, out);
+function gcCollectVarsInTriple(tr, out) {
+  gcCollectVarsInTerm(tr.s, out);
+  gcCollectVarsInTerm(tr.p, out);
+  gcCollectVarsInTerm(tr.o, out);
 }
 
-function _gcCollectVarsInGoals(goals, out) {
-  for (const g of goals) _gcCollectVarsInTriple(g, out);
+function gcCollectVarsInGoals(goals, out) {
+  for (const g of goals) gcCollectVarsInTriple(g, out);
 }
 
-function _substSizeOver(subst, limit) {
+function substSizeOver(subst, limit) {
   let c = 0;
   for (const _k in subst) {
     if (++c > limit) return true;
@@ -3869,9 +3818,9 @@ function _substSizeOver(subst, limit) {
   return false;
 }
 
-function _gcCompactForGoals(subst, goals, answerVars) {
+function gcCompactForGoals(subst, goals, answerVars) {
   const keep = new Set(answerVars);
-  _gcCollectVarsInGoals(goals, keep);
+  gcCollectVarsInGoals(goals, keep);
 
   const expanded = new Set();
   const queue = Array.from(keep);
@@ -3885,7 +3834,7 @@ function _gcCompactForGoals(subst, goals, answerVars) {
     if (bound === undefined) continue;
 
     const before = keep.size;
-    _gcCollectVarsInTerm(bound, keep);
+    gcCollectVarsInTerm(bound, keep);
     if (keep.size !== before) {
       for (const nv of keep) {
         if (!expanded.has(nv)) queue.push(nv);
@@ -3900,12 +3849,12 @@ function _gcCompactForGoals(subst, goals, answerVars) {
   return out;
 }
 
-function _maybeCompactSubst(subst, goals, answerVars, depth) {
+function maybeCompactSubst(subst, goals, answerVars, depth) {
   // Keep the fast path fast.
   // Only compact when the substitution is clearly getting large, or
   // we are in a deep chain (where the quadratic behavior shows up).
-  if (depth < 128 && !_substSizeOver(subst, 256)) return subst;
-  return _gcCompactForGoals(subst, goals, answerVars);
+  if (depth < 128 && !substSizeOver(subst, 256)) return subst;
+  return gcCompactForGoals(subst, goals, answerVars);
 }
 
 
@@ -3921,9 +3870,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
 
   // Variables from the original goal list (needed by the caller to instantiate conclusions)
   const answerVars = new Set();
-  _gcCollectVarsInGoals(initialGoals, answerVars);
+  gcCollectVarsInGoals(initialGoals, answerVars);
   if (!initialGoals.length) {
-    results.push(_gcCompactForGoals(initialSubst, [], answerVars));
+    results.push(gcCompactForGoals(initialSubst, [], answerVars));
     return results;
   }
 
@@ -3935,7 +3884,7 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
     const state = stack.pop();
 
     if (!state.goals.length) {
-      results.push(_gcCompactForGoals(state.subst, [], answerVars));
+      results.push(gcCompactForGoals(state.subst, [], answerVars));
       continue;
     }
 
@@ -3951,9 +3900,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -3980,9 +3929,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -4001,9 +3950,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -4036,7 +3985,7 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         const newGoals = body.concat(restGoals);
-        const nextSubst = _maybeCompactSubst(composed, newGoals, answerVars, state.depth + 1);
+        const nextSubst = maybeCompactSubst(composed, newGoals, answerVars, state.depth + 1);
         stack.push({
           goals: newGoals,
           subst: nextSubst,
@@ -4363,6 +4312,135 @@ function printExplanation(df, prefixes) {
 // Misc helpers
 // ============================================================================
 
+// Turn RDF Collections described with rdf:first/rdf:rest (+ rdf:nil) into ListTerm terms.
+// This mutates triples/rules in-place so list:* builtins work on RDF-serialized lists too.
+function materializeRdfLists(triples, forwardRules, backwardRules) {
+  const RDF_FIRST = RDF_NS + "first";
+  const RDF_REST  = RDF_NS + "rest";
+  const RDF_NIL   = RDF_NS + "nil";
+
+  function nodeKey(t) {
+    if (t instanceof Blank) return "B:" + t.label;
+    if (t instanceof Iri) return "I:" + t.value;
+    return null;
+  }
+
+  // Collect first/rest arcs from *input triples*
+  const firstMap = new Map(); // key(subject) -> Term (object)
+  const restMap  = new Map(); // key(subject) -> Term (object)
+  for (const tr of triples) {
+    if (!(tr.p instanceof Iri)) continue;
+    const k = nodeKey(tr.s);
+    if (!k) continue;
+    if (tr.p.value === RDF_FIRST) firstMap.set(k, tr.o);
+    else if (tr.p.value === RDF_REST) restMap.set(k, tr.o);
+  }
+  if (!firstMap.size && !restMap.size) return;
+
+  const cache = new Map();     // key(node) -> ListTerm
+  const visiting = new Set();  // cycle guard
+
+  function buildListForKey(k) {
+    if (cache.has(k)) return cache.get(k);
+    if (visiting.has(k)) return null; // cycle => not a well-formed list
+    visiting.add(k);
+
+    // rdf:nil => ()
+    if (k === "I:" + RDF_NIL) {
+      const empty = new ListTerm([]);
+      cache.set(k, empty);
+      visiting.delete(k);
+      return empty;
+    }
+
+    const head = firstMap.get(k);
+    const tail = restMap.get(k);
+    if (head === undefined || tail === undefined) {
+      visiting.delete(k);
+      return null; // not a full cons cell
+    }
+
+    const headTerm = rewriteTerm(head);
+
+    let tailListElems = null;
+    if (tail instanceof Iri && tail.value === RDF_NIL) {
+      tailListElems = [];
+    } else {
+      const tk = nodeKey(tail);
+      if (!tk) {
+        visiting.delete(k);
+        return null;
+      }
+      const tailList = buildListForKey(tk);
+      if (!tailList) {
+        visiting.delete(k);
+        return null;
+      }
+      tailListElems = tailList.elems;
+    }
+
+    const out = new ListTerm([headTerm, ...tailListElems]);
+    cache.set(k, out);
+    visiting.delete(k);
+    return out;
+  }
+
+  function rewriteTerm(t) {
+    // Replace list nodes (Blank/Iri) by their constructed ListTerm when possible
+    const k = nodeKey(t);
+    if (k) {
+      const built = buildListForKey(k);
+      if (built) return built;
+      // Also rewrite rdf:nil even if not otherwise referenced
+      if (t instanceof Iri && t.value === RDF_NIL) return new ListTerm([]);
+      return t;
+    }
+    if (t instanceof ListTerm) {
+      let changed = false;
+      const elems = t.elems.map(e => {
+        const r = rewriteTerm(e);
+        if (r !== e) changed = true;
+        return r;
+      });
+      return changed ? new ListTerm(elems) : t;
+    }
+    if (t instanceof OpenListTerm) {
+      let changed = false;
+      const prefix = t.prefix.map(e => {
+        const r = rewriteTerm(e);
+        if (r !== e) changed = true;
+        return r;
+      });
+      return changed ? new OpenListTerm(prefix, t.tailVar) : t;
+    }
+    if (t instanceof FormulaTerm) {
+      for (const tr of t.triples) rewriteTriple(tr);
+      return t;
+    }
+    return t;
+  }
+
+  function rewriteTriple(tr) {
+    tr.s = rewriteTerm(tr.s);
+    tr.p = rewriteTerm(tr.p);
+    tr.o = rewriteTerm(tr.o);
+  }
+
+  // Pre-build all reachable list heads
+  for (const k of firstMap.keys()) buildListForKey(k);
+
+  // Rewrite input triples + rules in-place
+  for (const tr of triples) rewriteTriple(tr);
+  for (const r of forwardRules) {
+    for (const tr of r.premise) rewriteTriple(tr);
+    for (const tr of r.conclusion) rewriteTriple(tr);
+  }
+  for (const r of backwardRules) {
+    for (const tr of r.premise) rewriteTriple(tr);
+    for (const tr of r.conclusion) rewriteTriple(tr);
+  }
+}
+
 function localIsoDateTimeString(d) {
   function pad(n, width = 2) {
     return String(n).padStart(width, "0");
@@ -4450,6 +4528,9 @@ function main() {
   const [prefixes, triples, frules, brules] = parser.parseDocument();
   // console.log(JSON.stringify([prefixes, triples, frules, brules], null, 2));
 
+  // Build internal ListTerm values from rdf:first/rdf:rest (+ rdf:nil) input triples
+  materializeRdfLists(triples, frules, brules);
+
   const facts = triples.filter(tr => isGroundTriple(tr));
   const derived = forwardChain(facts, frules, brules);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.5.33",
+  "version": "1.5.35",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [