eyeprolog 1.2.14 → 1.2.16

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.16",
   "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/src/solver.js

@@ -490,10 +490,11 @@ function normalizeHostResourceError(error) {
   const message = String(error?.message ?? '');
   // V8 reports exhausted Map/Set capacity as a host RangeError.  ISO 7.12.2 h
   // requires processor resource exhaustion to surface as resource_error/1,
-  // with the resource atom implementation dependent.  EyeProlog uses the
-  // finite_memory spelling already accepted by its ISO conformance corpus.
+  // with the resource atom implementation dependent.  A finite host capacity
+  // ceiling is reported as `memory`; reserve `finite_memory` for the separate
+  // convention where no finite amount of memory can complete the computation.
   if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
-    return new PrologError('resource_error(finite_memory)');
+    return new PrologError('resource_error(memory)');
   }
   return error;
 }

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.
@@ -2182,22 +2221,27 @@ open(X) :- candidate(X), \\+ closed(X).
       },
     },
     {
-      name: 'host Map capacity errors become ISO resource errors',
+      name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {
-        const registry = new BuiltinRegistry();
-        registry.add('exhaust_map', 0, function* () {
-          throw new RangeError('Map maximum size exceeded');
-        });
-        const solver = new Solver(Program.parse(''), { registry });
-        const goal = parseGoalText('exhaust_map');
-        let caught = null;
-        try {
-          [...solver.solve([goal], new Env(), 0)];
-        } catch (error) {
-          caught = error;
+        for (const [predicate, message] of [
+          ['exhaust_map', 'Map maximum size exceeded'],
+          ['exhaust_set', 'Set maximum size exceeded'],
+        ]) {
+          const registry = new BuiltinRegistry();
+          registry.add(predicate, 0, function* () {
+            throw new RangeError(message);
+          });
+          const solver = new Solver(Program.parse(''), { registry });
+          const goal = parseGoalText(predicate);
+          let caught = null;
+          try {
+            [...solver.solve([goal], new Env(), 0)];
+          } catch (error) {
+            caught = error;
+          }
+          assertEqual(caught?.name, 'PrologError', `${predicate} normalized error type`);
+          assertEqual(caught?.formal, 'resource_error(memory)', `${predicate} normalized resource error`);
         }
-        assertEqual(caught?.name, 'PrologError', 'normalized error type');
-        assertEqual(caught?.formal, 'resource_error(finite_memory)', 'normalized resource error');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1823,8 +1823,12 @@ sorted-list operation. No process-global variable registry or creation ordinal
 is retained or exposed through later comparisons.
 
 Host capacity failures that V8 reports as `Map maximum size exceeded` or `Set`
-`maximum size exceeded` are normalized at the solver boundary to the ISO error
-`resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
+`maximum size exceeded` are normalized at the solver boundary to
+`resource_error(memory)` instead of leaking a JavaScript `RangeError`. ISO
+13211-1 leaves the resource atom implementation dependent. EyeProlog uses
+`memory` for a finite host allocation/capacity ceiling and reserves the
+`finite_memory` spelling for the distinct convention where no finite amount of
+memory could complete the computation.
 
 ### Implementation boundary
 
@@ -5170,8 +5174,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 +6408,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