eyeprolog 1.2.14 → 1.2.15

package/README.md

@@ -79,10 +79,12 @@ member_test ?- member(X, [prolog, logic]).
 ;  X = logic.
 ```
 
-A label may contain several comma-separated metadata fields. When a query has
-multiple indented answer descriptions, each description is checked and counted
-independently, so one failed expectation does not prevent the later ones from
-running.
+A label is simply the first argument of the ordinary `(?-)/2` term, so it may
+use any normal Prolog term syntax; EyeProlog only requires it to be ground when
+the quad is checked. A non-ground label is a quad failure, not a source syntax
+error, and later quads still run. When a query has multiple indented answer
+descriptions, each description is checked and counted independently, so one
+failed expectation does not prevent the later ones from running.
 
 ## Strict ISO/IEC 13211-1 core
 

package/package.json

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

package/src/parser.js

@@ -794,13 +794,47 @@ class Parser {
         accept(clause);
         continue;
       }
+      // Program clauses historically parse comma separately from the head, so
+      // keep that grammar unchanged.  A quad id, however, is simply the first
+      // argument of the ordinary ?-/2 term.  If the initial head parse stops at
+      // a comma, tentatively reparse that left operand with the normal term
+      // grammar (where comma is the predefined priority-1000 xfy operator).
+      // Only when the resulting term is actually followed by ?- do we keep the
+      // tentative parse; otherwise restore the parser and retain the existing
+      // clause/DCG handling below.
+      const headState = {
+        pos: this.pos,
+        line: this.line,
+        anonymous: this.anonymous,
+        variables: new Map(this.variables),
+        previousToken: this.previousToken,
+        token: this.token,
+      };
+      const restoreHeadState = () => {
+        this.pos = headState.pos;
+        this.line = headState.line;
+        this.anonymous = headState.anonymous;
+        this.variables = new Map(headState.variables);
+        this.previousToken = headState.previousToken;
+        this.token = headState.token;
+      };
+
       let head = this.parseTerm(3);
-      // Both a quad label and a TS 13211-3 semicontext may contain one or more
-      // unparenthesized commas before their priority-1200 operator.  Parse the
-      // complete comma sequence here instead of stopping after one separator;
-      // portable quad labels commonly carry several metadata fields, e.g.
-      // `9, "case", passes ?- Goal.`.  Build the standard right-associative
-      // comma term so this is the same label as `(9, "case", passes)`.
+      if (this.token.type === TOK.COMMA && !this.strictIso) {
+        restoreHeadState();
+        const quadId = this.parseTerm(3, true);
+        if (this.operatorTokenName() === '?-') {
+          this.advance();
+          this.parseQuad(quadId, line, accept);
+          continue;
+        }
+        restoreHeadState();
+        head = this.parseTerm(3);
+      }
+
+      // Outside quad syntax, preserve the existing program-level comma rule,
+      // including the TS 13211-3 semicontext boundary.  This is deliberately
+      // not a grammar for quad ids.
       if (this.token.type === TOK.COMMA) {
         const items = [head];
         let extraCommaLine = null;
@@ -809,9 +843,6 @@ class Parser {
           this.advance();
           items.push(this.parseTerm(3));
         }
-        // Historically the program grammar admitted exactly one comma in a
-        // DCG semicontext.  Keep that boundary: the broader comma sequence is
-        // specifically the quad-label extension, not a new DCG syntax.
         if (extraCommaLine != null && this.operatorTokenName() !== '?-') {
           throw new Error(`parse line ${extraCommaLine}: expected ., got ,`);
         }

package/test/run-regression.mjs

@@ -279,8 +279,11 @@ why(
       },
     },
     {
-      name: 'quad labels accept multiple metadata fields and each answer description is independent',
+      name: 'quad ids use ordinary term syntax and each answer description is independent',
       run: () => {
+        // Issue #21: the first argument of ?-/2 is an ordinary Prolog term.
+        // The commas here are the normal priority-1000 comma operator, not a
+        // special metadata grammar owned by the quad parser.
         const source = `9, "✳54·43", passes
 ` +
           `?- X is 1+1.
@@ -298,14 +301,50 @@ why(
         const program = Program.parseSources([{ text: source, filename: 'issue-21.pl' }]);
         assertEqual(program.quads.length, 1, 'query group count');
         assertEqual(program.quads[0].answers.length, 4, 'answer-description count');
-        assertEqual(program.quads[0].id.name, ',', 'outer label comma');
-        assertEqual(program.quads[0].id.args[1].name, ',', 'right-associated label comma');
+        assertEqual(program.quads[0].id.name, ',', 'ordinary outer comma operator');
+        assertEqual(program.quads[0].id.args[1].name, ',', 'ordinary right-associated comma operator');
         const result = publicApi.runQuads(program);
         assertEqual(result.total, 4, 'answer-description total');
         assertEqual(result.passed, 4, 'answer-description passed');
         assertEqual(result.failed, 0, 'answer-description failed');
         assertEqual(result.stdout, 'quads: 4 run, 4 passed, 0 failed.\n', 'issue #21 report');
 
+        // No convention is imposed on the id term. Functional/list/curly and
+        // non-comma operator forms all go through the same ordinary term parser.
+        const ordinaryIds = Program.parse(
+          `meta(9, passes) ?- true.
+   true.
+` +
+          `[9, passes] ?- true.
+   true.
+` +
+          `{passes} ?- true.
+   true.
+` +
+          `(alpha ; beta) ?- true.
+   true.
+`,
+        );
+        assertEqual(ordinaryIds.quads.length, 4, 'ordinary id term count');
+        assertEqual(publicApi.runQuads(ordinaryIds).stdout, 'quads: 4 run, 4 passed, 0 failed.\n',
+          'ordinary id term report');
+
+        // Groundness is a quad semantic check, not source syntax. A bad id is
+        // reported as a test failure and processing continues to the next quad.
+        const nonGround = publicApi.runQuads(
+          `Id ?- true.
+   true.
+` +
+          `ok ?- true.
+   true.
+`,
+        );
+        assertEqual(nonGround.total, 2, 'non-ground id does not abort parsing');
+        assertEqual(nonGround.passed, 1, 'following quad still passes');
+        assertEqual(nonGround.failed, 1, 'non-ground id is a quad failure');
+        assertIncludes(nonGround.stdout, 'quads: BAD_ID Id, <input>:1', 'non-ground id diagnostic');
+        assertIncludes(nonGround.stdout, 'quads: 2 run, 1 passed, 1 failed.', 'non-ground continuation summary');
+
         const continuing = publicApi.runQuads(
           `case ?- X is 1+1.
    X = 3.

package/the-art-of-eyeprolog.md

@@ -5170,8 +5170,11 @@ from the parsed `?-/1` or `?-/2` term rather than from one privileged surface
 spelling. Thus `Label ?- Query.`, `?-(Label, Query).`, mixed forms such as
 `?-((Label), Query).`, quoted-functor notation, and a parenthesized whole
 `(?-(Label, Query)).` denote the same quad when followed by indented answer
-descriptions. In `--iso-strict` mode this quad interpretation is disabled, and
-`?-/2` remains ordinary Prolog term syntax.
+descriptions. `Label` itself is parsed with the ordinary Prolog term grammar:
+there is no quad-specific comma or metadata syntax. The runner requires the
+resulting first argument to be ground; if it is not, that quad is reported as
+`BAD_ID` and later quads are still processed. 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
@@ -6401,7 +6404,11 @@ colors ?- color(X).
 ```
 
 Run all quads in a file with `eyeprolog --quads file.pl` or `eyeprolog -q
-file.pl`. A label such as `colors` is optional. Loading the file normally only
+file.pl`. A label such as `colors` is optional. A label is not a separate
+mini-language: it is the ordinary first argument of `(?-)/2`, and therefore may
+be any Prolog term admitted there by the normal term grammar. Quad execution
+requires that argument to be ground; a non-ground label is reported as a quad
+failure rather than aborting source parsing. Loading the file normally only
 records its quads; it does not execute them or add their queries and answers as
 program clauses. A quad run prints a summary and exits with status `1` when any
 description fails. Quad mode imports `library(prologue)` as a compatibility