eyeprolog 1.2.0 → 1.2.1

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/parser.js

@@ -663,8 +663,7 @@ class Parser {
     }
     return this.source[start] === ' ' || this.source[start] === '\t';
   }
-  parseQuad(id, line, accept) {
-    const query = this.parseTerm(0, true);
+  parseQuadAnswers(id, query, line, accept) {
     this.expect(TOK.DOT, '.');
     this.advance();
 
@@ -684,28 +683,38 @@ class Parser {
       source: { filename: this.filename, line },
     });
   }
+  parseQuad(id, line, accept) {
+    const query = this.parseTerm(0, true);
+    this.parseQuadAnswers(id, query, line, accept);
+  }
+  parseQuadTerm(term, line, accept) {
+    if (term.type !== COMPOUND || term.name !== '?-' || ![1, 2].includes(term.arity)) return false;
+    const id = term.arity === 2 ? term.args[0] : null;
+    const query = term.args[term.arity - 1];
+    this.parseQuadAnswers(id, query, line, accept);
+    return true;
+  }
   parseProgram(emit = null) {
     const clauses = emit ? null : [];
     let clauseNumber = 0;
     const accept = emit ?? ((clause) => clauses.push(clause));
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
-      if (this.operatorTokenName() === '?-') {
-        if (this.strictIso) {
-          // In Part 1, ?- is the predefined 1200 fx operator.  A strict-core
-          // source therefore reads it as an ordinary term rather than giving
-          // it EyeProlog's top-level quad meaning.
-          const head = this.parseTerm(0, true);
-          this.expect(TOK.DOT, '.');
+      // In the normal EyeProlog profile, canonical functional ?-/1 and
+      // ?-/2 notation denotes the same quad marker as the corresponding
+      // operator notation.  Keep the existing operator-form query parsing so
+      // a query containing comma remains wholly to the right of `?-`, while
+      // functional notation is parsed as a term and then decomposed by arity.
+      if (this.operatorTokenName() === '?-' && !this.strictIso) {
+        if (this.peek() === '(') {
+          const quadTerm = this.parseTerm(0, true);
+          if (!this.parseQuadTerm(quadTerm, line, accept)) {
+            throw new Error(`parse line ${line}: bad quad term`);
+          }
+        } else {
           this.advance();
-          const clause = { head, body: [] };
-          clauseNumber++;
-          if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
-          accept(clause);
-          continue;
+          this.parseQuad(null, line, accept);
         }
-        this.advance();
-        this.parseQuad(null, line, accept);
         continue;
       }
       if (this.token.type === TOK.IF) {
@@ -740,6 +749,13 @@ class Parser {
         continue;
       }
       let head = this.parseTerm(3);
+      // Both a quad label and a TS 13211-3 semicontext may contain an
+      // unparenthesized comma before their priority-1200 operator.  Assemble
+      // that left operand before deciding whether the marker is ?- or -->.
+      if (this.token.type === TOK.COMMA) {
+        this.advance();
+        head = compound(',', [head, this.parseTerm(3)]);
+      }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {
           // There is no predefined infix ?-/2 in strict core mode.  If a
@@ -761,13 +777,6 @@ class Parser {
         this.parseQuad(head, line, accept);
         continue;
       }
-      // ISO/IEC TS 13211-3 grammar rules use -->/2 at the same top-level
-      // priority as clauses.  The left side may include an unparenthesized
-      // semicontext: NonTerminal, Terminals --> Body.
-      if (this.token.type === TOK.COMMA) {
-        this.advance();
-        head = compound(',', [head, this.parseTerm(3)]);
-      }
       if (this.operatorTokenName() === '-->') {
         this.advance();
         const grammarBody = this.parseTerm(0, true);

package/test/run-regression.mjs

@@ -221,6 +221,43 @@ why(
         assertEqual(program.quads[1].query.args[1].name, '.', 'dot atom');
       },
     },
+    {
+      name: 'quad parser treats operator and functional ?- notation equivalently',
+      run: () => {
+        const labelled = Program.parse(
+          `0,passes
+  ?- X = 1.
+     X = 1.
+`,
+        );
+        assertEqual(labelled.quads.length, 1, 'labelled quad count');
+        assertEqual(labelled.clauses.length, 0, 'labelled quad clause count');
+        assertEqual(labelled.quads[0].id.name, ',', 'comma label functor');
+        assertEqual(labelled.quads[0].query.name, '=', 'labelled quad query');
+        const labelledReport = publicApi.runQuads(labelled);
+        assertEqual(labelledReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'labelled quad report');
+
+        const functional = Program.parse(
+          `?-(','(0,passes),=(X,1)).
+   X = 1.
+`,
+        );
+        assertEqual(functional.quads.length, 1, 'functional quad count');
+        assertEqual(functional.clauses.length, 0, 'functional quad clause count');
+        assertEqual(functional.quads[0].id.name, ',', 'functional comma label functor');
+        assertEqual(functional.quads[0].query.name, '=', 'functional quad query');
+        assertEqual(termToString(functional.quads[0].id), termToString(labelled.quads[0].id),
+          'operator and functional labels are equivalent');
+        assertEqual(termToString(functional.quads[0].query), termToString(labelled.quads[0].query),
+          'operator and functional queries are equivalent');
+        const functionalReport = publicApi.runQuads(functional);
+        assertEqual(functionalReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'functional quad report');
+
+        const strict = Program.parse(`?-(','(0,passes),=(X,1)).\n`, { isoStrict: true });
+        assertEqual(strict.quads.length, 0, 'strict mode has no quads');
+        assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
+      },
+    },
     {
       name: 'runQuads checks portable answer descriptions',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5146,7 +5146,11 @@ contains `?-` at priority 1200 with specifier `fx`, so
 an optional label before the query marker (`Label ?- Query.`), so while quad
 syntax is supported it additionally exposes `?-` at priority 1200 with
 specifier `xfx` as an implementation-specific operator. Consequently
-`current_op(Priority, Specifier, ?-)` enumerates both definitions.
+`current_op(Priority, Specifier, ?-)` enumerates both definitions. At top level in the normal EyeProlog profile, the quad marker is recognized
+after term parsing, so equivalent syntax stays equivalent: `Label ?- Query.`
+and canonical `?-(Label, Query).` denote the same labelled quad when followed
+by its indented answer descriptions. In `--iso-strict` mode this quad
+interpretation is disabled, and `?-/2` remains ordinary Prolog term syntax.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -6361,7 +6365,10 @@ console.log(report.passed, report.failed, report.stdout);
 The syntax follows the “queries using answer descriptions” convention used by
 Trealla and the ISO Prolog working examples. Because answer descriptions are
 layout-sensitive, indent every description while keeping ordinary clause heads
-and the next quad query at the left margin.
+and the next quad query at the left margin. A comma may be part of a quad label,
+including across layout before `?-`. Canonical functional notation is
+semantically equivalent: `?-(Label, Query).` followed by the same indented
+answer descriptions creates the same labelled quad as `Label ?- Query.`.
 
 Statistics are comparative evidence, not a score in isolation. Preserve the
 program, input, runtime version, selected query, answers, and counters together.