eyeling 1.6.21 → 1.6.23

package/README.md

@@ -157,33 +157,6 @@ The CLI prints only newly derived forward facts.
 - the backward prover is **iterative** (explicit stack), so deep chains won’t blow the JS call stack
 - for very deep backward chains, substitutions may be compactified (semantics-preserving) to avoid quadratic “copy a growing substitution object” behavior
 
-## Parsing: practical N3 subset
-
-Supported:
-
-- `@prefix` / `@base`
-- triples with `;` and `,`
-- variables `?x`
-- blank nodes:
-  - anonymous `[]`
-  - property lists `[ :p :o; :q :r ]`
-- collections `( ... )`
-- quoted formulas `{ ... }`
-- implications:
-  - forward rules `{ P } => { C } .`
-  - backward rules `{ H } <= { B } .`
-- datatyped literals with `^^`
-- language-tagged string literals: `"hello"@en`, `"colour"@en-GB`
-- long string literals: `"""..."""` (can contain newlines; can also carry a language tag)
-- inverted predicate sugar: `?x <- :p ?y` (swaps subject/object for that predicate)
-- resource paths (forward `!` and reverse `^`): `:joe!:hasAddress!:hasCity "Metropolis".`
-- `#` line comments
-
-Non-goals / current limits:
-
-- not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
-- proof output is local per derived triple (not a global exported proof tree)
-
 ## Blank nodes and quantification (pragmatic N3/EYE-style)
 
 `eyeling` follows the usual N3 intuition:
@@ -207,7 +180,7 @@ During reasoning:
 
 - any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
 
-## Inference fuse — `{ ... } => false.`
+## Inference fuse
 
 Rules whose conclusion is `false` are treated as hard failures:
 
@@ -220,7 +193,27 @@ Rules whose conclusion is `false` are treated as hard failures:
 
 As soon as the premise is provable, `eyeling` exits with status code `2`.
 
-## Built-ins (overview)
+## Syntax + built-ins:
+
+`eyeling`’s parser targets (nearly) the full *Notation3 Language* grammar from the W3C N3 Community Group:
+https://w3c.github.io/N3/spec/
+
+In practice this means: it’s a Turtle superset that also accepts quoted formulas, rules, paths, and the N3 “syntax shorthand”
+operators (`=`, `=>`, `<=`) described in the spec.
+
+Commonly used N3/Turtle features:
+
+- Prefix/base directives (`@prefix` / `@base`, and SPARQL-style `PREFIX` / `BASE`)
+- Triples with `;` and `,`
+- Variables (`?x`)
+- Blank nodes (`[]`, and `[ :p :o; :q :r ]`)
+- Collections `( ... )`
+- Quoted formulas `{ ... }`
+- Implications (`=>`, `<=`)
+- Datatyped literals (`^^`) and language tags (`"..."@en`)
+- Inverse predicate sugar (`<-` and keyword forms like `is ... of`)
+- Resource paths (`!` and `^`)
+- `#` line comments
 
 `eyeling` implements a pragmatic subset of common N3 builtin families and evaluates them during backward goal proving:
 

package/eyeling.js

@@ -759,8 +759,9 @@ function lex(inputText) {
 // ===========================================================================
 
 class PrefixEnv {
-  constructor(map) {
-    this.map = map || {}; // prefix -> IRI
+  constructor(map, baseIri) {
+    this.map = map || {}; // prefix -> IRI (including "" for @prefix :)
+    this.baseIri = baseIri || ''; // base IRI for resolving <relative>
   }
 
   static newDefault() {
@@ -774,14 +775,18 @@ class PrefixEnv {
     m['list'] = LIST_NS;
     m['time'] = TIME_NS;
     m['genid'] = SKOLEM_NS;
-    m[''] = '';
-    return new PrefixEnv(m);
+    m[''] = ''; // empty prefix default namespace
+    return new PrefixEnv(m, ''); // base IRI starts empty
   }
 
   set(pref, base) {
     this.map[pref] = base;
   }
 
+  setBase(baseIri) {
+    this.baseIri = baseIri || '';
+  }
+
   expandQName(q) {
     if (q.includes(':')) {
       const [p, local] = q.split(':', 2);
@@ -954,6 +959,31 @@ class Parser {
       } else if (this.peek().typ === 'AtBase') {
         this.next();
         this.parseBaseDirective();
+      } else if (
+        // SPARQL-style/Turtle-style directives (case-insensitive, no trailing '.')
+        this.peek().typ === 'Ident' &&
+        typeof this.peek().value === 'string' &&
+        this.peek().value.toLowerCase() === 'prefix' &&
+        this.toks[this.pos + 1] &&
+        this.toks[this.pos + 1].typ === 'Ident' &&
+        typeof this.toks[this.pos + 1].value === 'string' &&
+        // Require PNAME_NS form (e.g., "ex:" or ":") to avoid clashing with a normal triple starting with IRI "prefix".
+        this.toks[this.pos + 1].value.endsWith(':') &&
+        this.toks[this.pos + 2] &&
+        (this.toks[this.pos + 2].typ === 'IriRef' || this.toks[this.pos + 2].typ === 'Ident')
+      ) {
+        this.next(); // consume PREFIX keyword
+        this.parseSparqlPrefixDirective();
+      } else if (
+        this.peek().typ === 'Ident' &&
+        typeof this.peek().value === 'string' &&
+        this.peek().value.toLowerCase() === 'base' &&
+        this.toks[this.pos + 1] &&
+        // SPARQL BASE requires an IRIREF.
+        this.toks[this.pos + 1].typ === 'IriRef'
+      ) {
+        this.next(); // consume BASE keyword
+        this.parseSparqlBaseDirective();
       } else {
         const first = this.parseTerm();
         if (this.peek().typ === 'OpImplies') {
@@ -970,15 +1000,16 @@ class Parser {
           let more;
 
           if (this.peek().typ === 'Dot') {
-            // Allow a bare blank-node property list statement, e.g. `[ a :Statement ].`
-            const lastTok = this.toks[this.pos - 1];
-            if (this.pendingTriples.length > 0 && lastTok && lastTok.typ === 'RBracket') {
+            // N3 grammar allows: triples ::= subject predicateObjectList?
+            // So a bare subject followed by '.' is syntactically valid.
+            // If the subject was a path / property-list that generated helper triples,
+            // we emit those; otherwise this statement contributes no triples.
+            more = [];
+            if (this.pendingTriples.length > 0) {
               more = this.pendingTriples;
               this.pendingTriples = [];
-              this.next(); // consume '.'
-            } else {
-              throw new Error(`Unexpected '.' after term; missing predicate/object list`);
             }
+            this.next(); // consume '.'
           } else {
             more = this.parsePredicateObjectList(first);
             this.expectDot();
@@ -1020,7 +1051,7 @@ class Parser {
     const tok2 = this.next();
     let iri;
     if (tok2.typ === 'IriRef') {
-      iri = tok2.value || '';
+      iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
     } else if (tok2.typ === 'Ident') {
       iri = this.prefixes.expandQName(tok2.value || '');
     } else {
@@ -1034,14 +1065,57 @@ class Parser {
     const tok = this.next();
     let iri;
     if (tok.typ === 'IriRef') {
-      iri = tok.value || '';
+      iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
     } else if (tok.typ === 'Ident') {
       iri = tok.value || '';
     } else {
       throw new Error(`Expected IRI after @base, got ${tok.toString()}`);
     }
     this.expectDot();
-    this.prefixes.set('', iri);
+    this.prefixes.setBase(iri);
+  }
+
+  parseSparqlPrefixDirective() {
+    // SPARQL/Turtle-style PREFIX directive: PREFIX pfx: <iri>  (no trailing '.')
+    const tok = this.next();
+    if (tok.typ !== 'Ident') {
+      throw new Error(`Expected prefix name after PREFIX, got ${tok.toString()}`);
+    }
+    const pref = tok.value || '';
+    const prefName = pref.endsWith(':') ? pref.slice(0, -1) : pref;
+
+    const tok2 = this.next();
+    let iri;
+    if (tok2.typ === 'IriRef') {
+      iri = resolveIriRef(tok2.value || '', this.prefixes.baseIri || '');
+    } else if (tok2.typ === 'Ident') {
+      iri = this.prefixes.expandQName(tok2.value || '');
+    } else {
+      throw new Error(`Expected IRI after PREFIX, got ${tok2.toString()}`);
+    }
+
+    // N3/Turtle: PREFIX directives do not have a trailing '.', but accept it permissively.
+    if (this.peek().typ === 'Dot') this.next();
+
+    this.prefixes.set(prefName, iri);
+  }
+
+  parseSparqlBaseDirective() {
+    // SPARQL/Turtle-style BASE directive: BASE <iri>  (no trailing '.')
+    const tok = this.next();
+    let iri;
+    if (tok.typ === 'IriRef') {
+      iri = resolveIriRef(tok.value || '', this.prefixes.baseIri || '');
+    } else if (tok.typ === 'Ident') {
+      iri = tok.value || '';
+    } else {
+      throw new Error(`Expected IRI after BASE, got ${tok.toString()}`);
+    }
+
+    // N3/Turtle: BASE directives do not have a trailing '.', but accept it permissively.
+    if (this.peek().typ === 'Dot') this.next();
+
+    this.prefixes.setBase(iri);
   }
 
   parseTerm() {
@@ -1072,7 +1146,7 @@ class Parser {
     }
 
     if (typ === 'IriRef') {
-      const base = this.prefixes.map[''] || '';
+      const base = this.prefixes.baseIri || '';
       return internIri(resolveIriRef(val || '', base));
     }
     if (typ === 'Ident') {
@@ -1150,6 +1224,66 @@ class Parser {
       return new Blank(`_:b${this.blankCounter}`);
     }
 
+    // IRI property list: [ id <IRI> predicateObjectList? ]
+    // Lets you embed descriptions of an IRI directly in object position.
+    if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'id') {
+      this.next(); // consume 'id'
+      const iriTerm = this.parseTerm();
+
+      // N3 note: 'id' form is not meant to be used with blank node identifiers.
+      if (iriTerm instanceof Blank && iriTerm.label.startsWith('_:')) {
+        throw new Error("Cannot use 'id' keyword with a blank node identifier inside [...]");
+      }
+
+      // Optional ';' right after the id IRI (tolerated).
+      if (this.peek().typ === 'Semicolon') this.next();
+
+      // Empty IRI property list: [ id :iri ]
+      if (this.peek().typ === 'RBracket') {
+        this.next();
+        return iriTerm;
+      }
+
+      const subj = iriTerm;
+      while (true) {
+        let pred;
+        let invert = false;
+        if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
+          this.next();
+          pred = internIri(RDF_NS + 'type');
+        } else if (this.peek().typ === 'OpPredInvert') {
+          this.next(); // "<-"
+          pred = this.parseTerm();
+          invert = true;
+        } else {
+          pred = this.parseTerm();
+        }
+
+        const objs = [this.parseTerm()];
+        while (this.peek().typ === 'Comma') {
+          this.next();
+          objs.push(this.parseTerm());
+        }
+
+        for (const o of objs) {
+          this.pendingTriples.push(invert ? new Triple(o, pred, subj) : new Triple(subj, pred, o));
+        }
+
+        if (this.peek().typ === 'Semicolon') {
+          this.next();
+          if (this.peek().typ === 'RBracket') break;
+          continue;
+        }
+        break;
+      }
+
+      if (this.peek().typ !== 'RBracket') {
+        throw new Error(`Expected ']' at end of IRI property list, got ${JSON.stringify(this.peek())}`);
+      }
+      this.next();
+      return iriTerm;
+    }
+
     // [ predicateObjectList ]
     this.blankCounter += 1;
     const id = `_:b${this.blankCounter}`;
@@ -1225,15 +1359,15 @@ class Parser {
           throw new Error(`Expected '.' or '}', got ${this.peek().toString()}`);
         }
       } else {
-        // Allow a bare blank-node property list statement inside a formula, e.g. `{ [ a :X ]. }`
+        // N3 grammar allows: triples ::= subject predicateObjectList?
+        // So a bare subject (optionally producing helper triples) is allowed inside formulas as well.
         if (this.peek().typ === 'Dot' || this.peek().typ === 'RBrace') {
-          const lastTok = this.toks[this.pos - 1];
-          if (this.pendingTriples.length > 0 && lastTok && lastTok.typ === 'RBracket') {
+          if (this.pendingTriples.length > 0) {
             triples.push(...this.pendingTriples);
             this.pendingTriples = [];
-            if (this.peek().typ === 'Dot') this.next();
-            continue;
           }
+          if (this.peek().typ === 'Dot') this.next();
+          continue;
         }
 
         triples.push(...this.parsePredicateObjectList(left));
@@ -1265,6 +1399,19 @@ class Parser {
       if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
         this.next();
         verb = internIri(RDF_NS + 'type');
+      } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'has') {
+        // N3 syntactic sugar: "S has P O." means "S P O."
+        this.next(); // consume "has"
+        verb = this.parseTerm();
+      } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'is') {
+        // N3 syntactic sugar: "S is P of O." means "O P S." (inverse; equivalent to "<-")
+        this.next(); // consume "is"
+        verb = this.parseTerm();
+        if (!(this.peek().typ === 'Ident' && (this.peek().value || '') === 'of')) {
+          throw new Error(`Expected 'of' after 'is <expr>', got ${this.peek().toString()}`);
+        }
+        this.next(); // consume "of"
+        invert = true;
       } else if (this.peek().typ === 'OpPredInvert') {
         this.next(); // "<-"
         verb = this.parseTerm();

package/package.json

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