eyeprolog 1.2.11 → 1.2.13

package/README.md

@@ -79,6 +79,11 @@ 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.
+
 ## Strict ISO/IEC 13211-1 core
 
 For portability and conformance work, run the Part 1 core with Technical

package/package.json

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

package/src/parser.js

@@ -746,11 +746,11 @@ class Parser {
     const accept = emit ?? ((clause) => clauses.push(clause));
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
-      // 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.
+      // Prefix operator notation needs one program-level distinction so
+      // a comma in `?- A, B.` remains inside the query rather than outside the
+      // prefix term. Ordinary functional notation is parsed as a term and then
+      // recognized structurally by parseQuadTerm; further equivalent spellings
+      // are recognized after the general head parser below.
       if (this.operatorTokenName() === '?-' && !this.strictIso) {
         if (this.peek() === '(') {
           const quadTerm = this.parseTerm(0, true);
@@ -795,12 +795,36 @@ 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 -->.
+      // 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.advance();
-        head = compound(',', [head, this.parseTerm(3)]);
+        const items = [head];
+        let extraCommaLine = null;
+        while (this.token.type === TOK.COMMA) {
+          if (items.length >= 2 && extraCommaLine == null) extraCommaLine = this.token.line;
+          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 ,`);
+        }
+        head = items.pop();
+        while (items.length > 0) head = compound(',', [items.pop(), head]);
+      }
+      // Parentheses and other ordinary term syntax may hide the surface ?-
+      // token from the program-level dispatch above.  Once the complete head
+      // term has been parsed, recognize the same ?-/1 or ?-/2 structure here.
+      // Requiring the following dot prevents an ordinary rule whose head just
+      // happens to be ?-/1 or ?-/2 from being consumed as a quad mid-clause.
+      if (!this.strictIso && this.token.type === TOK.DOT && this.parseQuadTerm(head, line, accept)) {
+        continue;
       }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {

package/src/quads.js

@@ -33,9 +33,14 @@ export function runQuads(source, options = {}) {
   const results = [];
   const lines = [];
   for (const quad of quads) {
-    const result = checkQuad(program, quad, options);
-    results.push(result);
-    if (!result.ok) lines.push(formatFailure(program, quad, result));
+    // Every indented answer description is an independent portable quad test.
+    // Re-run the query for each description so a failed expectation does not
+    // prevent later expectations for the same query from being checked.
+    for (const description of quad.answers) {
+      const result = checkQuadDescription(program, quad, description, options);
+      results.push(result);
+      if (!result.ok) lines.push(formatFailure(program, quad, result, description));
+    }
   }
   const passed = results.filter((result) => result.ok).length;
   const failed = results.length - passed;
@@ -43,15 +48,11 @@ export function runQuads(source, options = {}) {
   return { stdout: lines.join(''), total: results.length, passed, failed, results };
 }
 
-function checkQuad(program, quad, options) {
+function checkQuadDescription(program, quad, description, options) {
   if (quad.id != null && !termIsGround(quad.id, new Env())) {
     return { ok: false, kind: 'bad_identifier', expected: quad.id };
   }
-  for (const description of quad.answers) {
-    const checked = checkDescription(program, quad, description, options);
-    if (!checked.ok) return checked;
-  }
-  return { ok: true };
+  return checkDescription(program, quad, description, options);
 }
 
 function checkDescription(program, quad, description, options) {
@@ -398,14 +399,14 @@ function splitOperator(term, name) {
   return [term];
 }
 
-function formatFailure(program, quad, result) {
+function formatFailure(program, quad, result, description = quad.answers[0]) {
   const source = quad.source ?? { filename: '<input>', line: 1 };
   const label = quad.id == null ? '' : `${formatQuadTerm(program, quad.id)}, `;
   const reason = result.kind === 'malformed' ? 'MALFORMED'
     : result.kind === 'bad_identifier' ? 'BAD_ID'
       : result.kind === 'unsupported' ? 'UNSUPPORTED'
         : 'FAILED';
-  const expected = result.expected ?? quad.answers[0];
+  const expected = result.expected ?? description;
   return `quads: ${reason} ${label}${source.filename}:${source.line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` +
     `   expected: ${formatQuadTerm(program, expected)}.\n`;

package/test/run-regression.mjs

@@ -222,7 +222,7 @@ why(
       },
     },
     {
-      name: 'quad parser treats operator and functional ?- notation equivalently',
+      name: 'quad parser treats regular term spellings of ?- equivalently',
       run: () => {
         const labelled = Program.parse(
           `0,passes
@@ -253,9 +253,68 @@ why(
         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 });
+        // Issue #11 is about ordinary term syntax, not one privileged
+        // canonical spelling. Parentheses, quoted functor syntax, and mixed
+        // operator/functional notation must all denote the same ?-/2 term and
+        // therefore the same quad in the normal EyeProlog profile.
+        for (const [name, source] of [
+          ['mixed', `?-((0,passes), X = 1).\n   X = 1.\n`],
+          ['parenthesized', `(?-(','(0,passes),=(X,1))).\n   X = 1.\n`],
+          ['parenthesized mixed', `(?-((0,passes), X = 1)).\n   X = 1.\n`],
+          ['quoted functor', `'?-'(','(0,passes),=(X,1)).\n   X = 1.\n`],
+          ['quoted parenthesized', `('?-'(','(0,passes),=(X,1))).\n   X = 1.\n`],
+        ]) {
+          const regular = Program.parse(source);
+          assertEqual(regular.quads.length, 1, `${name} quad count`);
+          assertEqual(regular.clauses.length, 0, `${name} quad clause count`);
+          assertEqual(termToString(regular.quads[0].id), termToString(labelled.quads[0].id), `${name} label`);
+          assertEqual(termToString(regular.quads[0].query), termToString(labelled.quads[0].query), `${name} query`);
+          assertEqual(publicApi.runQuads(regular).stdout, 'quads: 1 run, 1 passed, 0 failed.\n', `${name} 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');
+        assertEqual(strict.clauses.length, 1, 'strict ?-/2 remains an ordinary term');
+      },
+    },
+    {
+      name: 'quad labels accept multiple metadata fields and each answer description is independent',
+      run: () => {
+        const source = `9, "✳54·43", passes
+` +
+          `?- X is 1+1.
+` +
+          `   X = 3, unexpected. % almost
+` +
+          `   X = 1, unexpected. % too low
+` +
+          `   X = 2.0, unexpected.
+` +
+          `% and after checking PM:
+` +
+          `   X = 2.
+`;
+        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');
+        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');
+
+        const continuing = publicApi.runQuads(
+          `case ?- X is 1+1.
+   X = 3.
+   X = 2.
+`,
+        );
+        assertEqual(continuing.total, 2, 'later descriptions still run after failure');
+        assertEqual(continuing.passed, 1, 'later passing description counted');
+        assertEqual(continuing.failed, 1, 'failed description counted');
+        assertIncludes(continuing.stdout, 'quads: 2 run, 1 passed, 1 failed.', 'continuation summary');
       },
     },
     {
@@ -275,10 +334,10 @@ why(
           `?- X = 1.\n   X = 2, unexpected.\n   X = 1.\n\n` +
           `?- catch(throw(ball), E, true).\n   E = ball | error(system_error, ...).\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'quads.pl' }]));
-        assertEqual(result.total, 12, 'quad total');
-        assertEqual(result.passed, 12, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 12 run, 12 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 13, 'answer-description total');
+        assertEqual(result.passed, 13, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
     {
@@ -288,10 +347,10 @@ why(
           `   throw(g(_X)).\n` +
           `   throw(g(X)), unexpected.\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'throw-copy-quad.pl' }]));
-        assertEqual(result.total, 1, 'quad total');
-        assertEqual(result.passed, 1, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 2, 'answer-description total');
+        assertEqual(result.passed, 2, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 2 run, 2 passed, 0 failed.\n', 'quad report');
 
         const forbiddenFresh = publicApi.runQuads(
           `?- throw(g(X)).\n   throw(g(_X)), unexpected.\n`,
@@ -396,9 +455,9 @@ c4 ?- call((!;1)).
           text: source,
           filename,
         }]));
-        assertEqual(result.total, 73, 'quad total');
-        assertEqual(result.passed, 73, 'quad passed');
-        assertEqual(result.stdout, 'quads: 73 run, 73 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 77, 'answer-description total');
+        assertEqual(result.passed, 77, 'answer-description passed');
+        assertEqual(result.stdout, 'quads: 77 run, 77 passed, 0 failed.\n', 'quad report');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5156,10 +5156,12 @@ 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. 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.
+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.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -6408,8 +6410,10 @@ descriptions; variables introduced only by a description are fresh. For example,
 a query `throw(g(X))` is described by `throw(g(_X))`, while
 `throw(g(X)), unexpected` verifies that ISO `throw/1` did not retain the query
 variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. Multiple
-indented descriptions after one query must all hold. `inputs/1` supplies and
-checks consumed characters; `outputs/1` checks emitted characters. `sto` marks
+indented descriptions after one query are independent checks: each re-runs the
+query, each is counted in the `quads:` summary, and a failing description does
+not suppress later descriptions for that query. `inputs/1` supplies and checks
+consumed characters; `outputs/1` checks emitted characters. `sto` marks
 an answer description that this finite-tree implementation skips. `loops` is
 checked with a deterministic solver-depth budget. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
@@ -6428,10 +6432,14 @@ 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. 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.`.
+and the next quad query at the left margin. A quad label may contain any number
+of comma-separated metadata fields, including across layout before `?-`; for
+example `9, "case", passes ?- Goal.` is one labelled query. Quad recognition
+is structural after ordinary term parsing: functional, mixed, quoted-functor,
+and parenthesized spellings of the same `?-/1` or `?-/2` term are semantically
+equivalent. For example `?-(Label, Query).` and `(?-(Label, Query)).`, followed
+by the same indented answer descriptions, create 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.