eyeling 1.5.27 → 1.5.29

package/eyeling.js

@@ -235,6 +235,12 @@ function lex(inputText) {
         i += 2;
         continue;
       }
+      // N3 predicate inversion: "<-" (swap subject/object for this predicate)
+      if (peek(1) === "-") {
+        tokens.push(new Token("OpPredInvert"));
+        i += 2;
+        continue;
+      }
       // Otherwise IRIREF <...>
       i++; // skip '<'
       const iriChars = [];
@@ -251,15 +257,21 @@ function lex(inputText) {
       continue;
     }
 
-    // 4) Datatype operator ^^
+    // 4) Path + datatype operators: !, ^, ^^
+    if (c === "!") {
+      tokens.push(new Token("OpPathFwd"));
+      i += 1;
+      continue;
+    }
     if (c === "^") {
       if (peek(1) === "^") {
         tokens.push(new Token("HatHat"));
         i += 2;
         continue;
-      } else {
-        throw new Error("Unexpected '^' (did you mean ^^?)");
       }
+      tokens.push(new Token("OpPathRev"));
+      i += 1;
+      continue;
     }
 
     // 5) Single-character punctuation
@@ -728,6 +740,28 @@ class Parser {
   }
 
   parseTerm() {
+    let t = this.parsePathItem();
+
+    while (this.peek().typ === "OpPathFwd" || this.peek().typ === "OpPathRev") {
+      const dir = this.next().typ;      // OpPathFwd | OpPathRev
+      const pred = this.parsePathItem();
+
+      this.blankCounter += 1;
+      const bn = new Blank(`_:b${this.blankCounter}`);
+
+      this.pendingTriples.push(
+        dir === "OpPathFwd"
+          ? new Triple(t, pred, bn)
+          : new Triple(bn, pred, t)
+      );
+
+      t = bn;
+    }
+
+    return t;
+  }
+
+  parsePathItem() {
     const tok = this.next();
     const typ = tok.typ;
     const val = tok.value;
@@ -823,9 +857,14 @@ class Parser {
     while (true) {
       // Verb (can also be 'a')
       let pred;
+      let invert = false;
       if (this.peek().typ === "Ident" && (this.peek().value || "") === "a") {
         this.next();
         pred = new Iri(RDF_NS + "type");
+      } else if (this.peek().typ === "OpPredInvert") {
+        this.next(); // consume "<-"
+        pred = this.parseTerm();
+        invert = true;
       } else {
         pred = this.parseTerm();
       }
@@ -838,7 +877,8 @@ class Parser {
       }
 
       for (const o of objs) {
-        this.pendingTriples.push(new Triple(subj, pred, o));
+        this.pendingTriples.push(invert ? new Triple(o, pred, subj)
+                                       : new Triple(subj, pred, o));
       }
 
       if (this.peek().typ === "Semicolon") {
@@ -904,16 +944,40 @@ class Parser {
 
   parsePredicateObjectList(subject) {
     const out = [];
+
+    // If the SUBJECT was a path, emit its helper triples first
+    if (this.pendingTriples.length > 0) {
+      out.push(...this.pendingTriples);
+      this.pendingTriples = [];
+    }
+
     while (true) {
       let verb;
+      let invert = false;
+
       if (this.peek().typ === "Ident" && (this.peek().value || "") === "a") {
         this.next();
         verb = new Iri(RDF_NS + "type");
+      } else if (this.peek().typ === "OpPredInvert") {
+        this.next(); // "<-"
+        verb = this.parseTerm();
+        invert = true;
       } else {
         verb = this.parseTerm();
       }
+
       const objects = this.parseObjectList();
-      for (const o of objects) out.push(new Triple(subject, verb, o));
+
+      // If VERB or OBJECTS contained paths, their helper triples must come
+      // before the triples that consume the path results (Easter depends on this).
+      if (this.pendingTriples.length > 0) {
+        out.push(...this.pendingTriples);
+        this.pendingTriples = [];
+      }
+
+      for (const o of objects) {
+        out.push(new Triple(invert ? o : subject, verb, invert ? subject : o));
+      }
 
       if (this.peek().typ === "Semicolon") {
         this.next();
@@ -923,11 +987,6 @@ class Parser {
       break;
     }
 
-    if (this.pendingTriples.length > 0) {
-      out.push(...this.pendingTriples);
-      this.pendingTriples = [];
-    }
-
     return out;
   }
 
@@ -2309,6 +2368,47 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     }
   }
 
+  // math:integerQuotient
+  // Schema: ( $a $b ) math:integerQuotient $q
+  // Cwm: divide first integer by second integer, ignoring remainder. :contentReference[oaicite:1]{index=1}
+  if (g.p instanceof Iri && g.p.value === MATH_NS + "integerQuotient") {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
+    const [a0, b0] = g.s.elems;
+
+    // Prefer exact integer division using BigInt when possible
+    const ai = parseIntLiteral(a0);
+    const bi = parseIntLiteral(b0);
+    if (ai !== null && bi !== null) {
+      if (bi === 0n) return [];
+      const q = ai / bi; // BigInt division truncates toward zero
+      const lit = new Literal(q.toString());
+      if (g.o instanceof Var) {
+        const s2 = { ...subst };
+        s2[g.o.name] = lit;
+        return [s2];
+      }
+      const s2 = unifyTerm(g.o, lit, subst);
+      return s2 !== null ? [s2] : [];
+    }
+
+    // Fallback: allow Number literals that still represent integers
+    const a = parseNum(a0);
+    const b = parseNum(b0);
+    if (a === null || b === null) return [];
+    if (!Number.isFinite(a) || !Number.isFinite(b) || b === 0) return [];
+    if (!Number.isInteger(a) || !Number.isInteger(b)) return [];
+
+    const q = Math.trunc(a / b);
+    const lit = new Literal(String(q));
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // math:exponentiation
   if (g.p instanceof Iri && g.p.value === MATH_NS + "exponentiation") {
     if (g.s instanceof ListTerm && g.s.elems.length === 2) {

package/package.json

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

package/test/api.test.js

@@ -636,6 +636,42 @@ ${U('s')} ${U('p')} ${U('o')}. # another trailing comment
 world"""@en.`,
     expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+(?:"""Hello[\\s\\S]*?world"""@en|"Hello\\\\nworld"@en)\\s*\\.`)],
   },
+
+  { name: '44 syntax: "<-" in predicate position swaps subject and object',
+    opt: { proofComments: false },
+    input: ` { ?s ${U('p')} ?o } => { ?s ${U('q')} ?o }.
+${U('a')} <-${U('p')} ${U('b')}.`,
+    expect: [new RegExp(`${EX}b>\\s+<${EX}q>\\s+<${EX}a>\\s*\\.`)],
+  },
+
+  { name: '45 syntax: "<-" works inside blank node property lists ([ ... ])',
+    opt: { proofComments: false },
+    input: ` ${U('s')} ${U('p')} [ <-${U('r')} ${U('o')} ].
+{ ${U('o')} ${U('r')} ?x } => { ?x ${U('q')} ${U('k')} }.`,
+    expect: [new RegExp(`_:b1\\s+<${EX}q>\\s+<${EX}k>\\s*\\.`)],
+  },
+
+  { name: '46 syntax: N3 resource paths (! / ^) expand to blank-node triples (forward chain)',
+    opt: { proofComments: false },
+    input: ` ${U('joe')}!${U('hasAddress')}!${U('hasCity')} ${U('name')} "Metropolis".
+{ ${U('joe')} ${U('hasAddress')} ?a } => { ?a ${U('q')} "addr" }.
+{ ?a ${U('hasCity')} ?c } => { ?c ${U('q')} "city" }.
+`,
+    expect: [
+      new RegExp(`_:b1\\s+<${EX}q>\\s+"addr"\\s*\\.`),
+      new RegExp(`_:b2\\s+<${EX}q>\\s+"city"\\s*\\.`),
+    ],
+  },
+
+  { name: '47 syntax: N3 resource paths support reverse steps (^) in the chain',
+    opt: { proofComments: false },
+    input: ` ${U('joe')}!${U('hasMother')}^${U('hasMother')} ${U('knows')} ${U('someone')}.
+{ ?sib ${U('hasMother')} ?mom. ${U('joe')} ${U('hasMother')} ?mom } => { ?sib ${U('q')} ${U('joe')} }.
+`,
+    expect: [
+      new RegExp(`_:b2\\s+<${EX}q>\\s+<${EX}joe>\\s*\\.`),
+    ],
+  },
 ];
 
 let passed = 0;