eyeprolog 1.5.87 → 1.5.89

package/package.json

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

package/src/quads.js

@@ -162,6 +162,21 @@ function checkAlternative(program, quad, alternative, options, context, unordere
   // matchLeaf accepts it once this disproof gate has been cleared.
   if (requiresSto && actual.nstoObserved) return { ok: false };
 
+  // The reverse of the check above: execution that actually triggered
+  // occurs-check produced an implementation-dependent outcome (ISO 7.3.3
+  // Note 2 -- succeed, loop, or fail are all conforming), even when none of
+  // this alternative's own leaves say so. A leaf making a positive claim
+  // about that outcome without an `sto` tag would silently misrepresent an
+  // implementation choice as a portably decided one (see issue #111's
+  // `\+ \+ -X=X` follow-up: a bare `false.` happens to match here, but only
+  // because this engine always occurs-checks -- a non-occurs-checking engine
+  // would see `true` instead). An `unexpected` leaf is a negative claim
+  // instead, and already has its own STO carve-out below
+  // (`stoPermitsUnexpected`, issue #60), so leave those alone here.
+  if (!requiresSto && actual.stoObserved && !leaves.some((leaf) => leaf.unexpected)) {
+    return { ok: false, alternative };
+  }
+
   if (hasInputSpec) {
     const leaf = leaves[0];
     const exactConsumption = actual.inputPosition === input.length;
@@ -994,24 +1009,46 @@ const FAILURE_LABELS = {
 
 // With several `|`-separated alternatives -- the norm for `sto`-annotated
 // queries -- a bare offending sub-term like `_B = [E|_B]` gives no sense of
-// which alternative it came from (issue #112's follow-up). Show that whole
-// alternative in place, and stand in for its siblings with `...` rather than
-// reproducing them (they were not the problem) or dropping them silently
-// (a reader can no longer tell how many alternatives, or which one, this was).
-// Returns null when the description has only one alternative to begin with:
-// there is then nothing to elide, and the existing plain rendering already
-// shows the whole thing.
+// which alternative it came from. Show that whole alternative in place, laid
+// out the same way the answer-description syntax itself lays out alternatives
+// and leaves (a leading `|` per alternative after the first, a leading `;`
+// per leaf after an alternative's first), and stand in for sibling
+// alternatives with a bare `...` rather than reproducing them (they were not
+// the problem) or dropping them silently (a reader can no longer tell how
+// many alternatives, or which one, this was) -- see issue #112's follow-up
+// (https://github.com/eyereasoner/eyeprolog/issues/112#issuecomment-5645403025).
+// Comments are not retained past parsing, so unlike a hand-written answer
+// description this reconstruction never has any to show. Returns null when
+// the description has only one alternative to begin with: there is then
+// nothing to elide, and the existing plain rendering already shows the whole
+// thing.
 function formatAlternativeContext(program, description, alternative) {
   const parts = splitOperator(description, '|');
   if (parts.length <= 1 || !parts.includes(alternative)) return null;
-  return parts.map((part) => (part === alternative ? formatQuadTerm(program, part) : '...')).join(' | ');
-}
-
-// A trailing `...` glued straight to a full stop reads as four dots; the
-// quad answer-description syntax itself always writes a space before the
-// period in that position (see `..., ad_infinitum` vs `... .`), so match it.
-function terminate(text) {
-  return text.endsWith('...') ? `${text} .` : `${text}.`;
+  // Every detail line under a `quads: ...` header shares one 3-space report
+  // margin (the same margin the plain `?- ...` and `expected: ...` lines
+  // already use) -- reproduce the answer-description syntax's own layout
+  // (a bare 3-space indent for the first alternative, a leading `|  `/`;  `
+  // marker for a later alternative/leaf) *inside* that margin, so a marker
+  // character lines up under the `?` above it rather than at column 0.
+  const margin = '   ';
+  const lines = [];
+  parts.forEach((part, index) => {
+    const marker = index === 0 ? '   ' : '|  ';
+    if (part !== alternative) {
+      lines.push(`${margin}${marker}...`);
+      return;
+    }
+    splitOperator(part, ';').forEach((leaf, leafIndex) => {
+      lines.push(`${margin}${leafIndex === 0 ? marker : ';  '}${formatQuadTerm(program, leaf)}`);
+    });
+  });
+  // A trailing `...` glued straight to a full stop reads as four dots; the
+  // answer-description syntax itself always writes a space before the period
+  // in that position (compare `..., ad_infinitum` with `... .`), so match it.
+  const last = lines.length - 1;
+  lines[last] = lines[last].endsWith('...') ? `${lines[last]} .` : `${lines[last]}.`;
+  return lines.join('\n');
 }
 
 function formatFailure(program, quad, result, description = quad.answers[0]) {
@@ -1029,12 +1066,14 @@ function formatFailure(program, quad, result, description = quad.answers[0]) {
   const detail = result.kind === 'undecided'
     ? `   undecided: ${result.reason}.\n`
     // When the offending sub-term already *is* the whole alternative (an
-    // `expected:` line would just repeat the context line), the context line
-    // alone is the full, non-redundant report.
+    // `expected:` line would just repeat the context lines), the context
+    // alone is the full, non-redundant report. formatAlternativeContext
+    // already lays out and terminates its own lines, so it needs no further
+    // wrapping here (unlike the plain single-line `expected:` case below).
     : context != null && expected === result.alternative
-      ? `   ${terminate(context)}\n`
+      ? `${context}\n`
       : context != null
-        ? `   ${terminate(context)}\n   expected: ${formatQuadTerm(program, expected)}.\n`
+        ? `${context}\n   expected: ${formatQuadTerm(program, expected)}.\n`
         : `   expected: ${formatQuadTerm(program, expected)}.\n`;
   return `quads: ${reason} ${label}${source.filename}:${line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` + detail;

package/test/regression/cases-regression.mjs

@@ -2584,8 +2584,18 @@ c4 ?- call((!;1)).
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'select-quad.pl' }]));
         assertEqual(result.total, 1, 'quad total');
         assertEqual(result.failed, 1, 'quad failed');
+        // Laid out the same way the answer-description syntax itself lays
+        // out alternatives (a leading `|`) and leaves (a leading `;`), per
+        // Ulrich's own proposed shape in that follow-up comment, inside the
+        // same 3-space report margin every other detail line under a
+        // `quads: ...` header uses -- so each `|`/`;` marker lines up under
+        // the `?` of the `?- ...` line above it, not at column 0.
         assertIncludes(result.stdout,
-          '   ... | sto, Xs = [E | Xs] ; Xs = [_A | _B], Ys = [E | Ys] ; ..., ad_infinitum | ... .\n',
+          '      ...\n' +
+          '   |  sto, Xs = [E | Xs]\n' +
+          '   ;  Xs = [_A | _B], Ys = [E | Ys]\n' +
+          '   ;  ..., ad_infinitum\n' +
+          '   |  ... .\n',
           'sibling-elided alternative context');
         assertIncludes(result.stdout, '   expected: Ys = [E | Ys].\n', 'still-precise offending sub-term');
       },
@@ -2681,6 +2691,33 @@ c4 ?- call((!;1)).
         assertIncludes(nsto.stdout, 'quads: FAILED 34, <input>:3', 'NSTO diagnostic');
       },
     },
+    {
+      name: 'quad sto is required, not merely tolerated, once execution observes occurs-check (issue #111 follow-up)',
+      run: () => {
+        // https://github.com/eyereasoner/eyeprolog/issues/111#issuecomment-5645863132:
+        // `\+ \+ -X=X` fails only because this engine always occurs-checks
+        // plain `=`/2 (ISO 7.3.3 Note 2 leaves succeed/loop/fail all
+        // conforming); a non-occurs-checking engine sees `-X=X` succeed
+        // (creating a cyclic X), so `\+ \+` sees `true` instead. A bare
+        // `false.` -- with no `sto` tag -- misrepresents that as a portably
+        // decided outcome, so it must be rejected even though it happens to
+        // match this engine's own behavior; only the honestly `sto`-tagged
+        // claim may pass.
+        const bare = publicApi.runQuads('?- \\+ \\+ -X=X.\n   false.\n');
+        assertEqual(bare.passed, 0, 'undeclared sto claim rejected');
+        assertEqual(bare.failed, 1, 'undeclared sto claim rejected');
+
+        const declared = publicApi.runQuads('?- \\+ \\+ -X=X.\n   sto, false.\n');
+        assertEqual(declared.passed, 1, 'declared sto claim accepted');
+        assertEqual(declared.failed, 0, 'declared sto claim accepted');
+
+        // An `unexpected` leaf is a negative claim with its own, separate STO
+        // carve-out (issue #60, tested above); this new rule must not touch it.
+        const unexpected = publicApi.runQuads('?- \\+ \\+ -X=X.\n   false, unexpected.\n');
+        assertEqual(unexpected.passed, 0, 'wrong negative claim still rejected on its own terms');
+        assertEqual(unexpected.failed, 1, 'wrong negative claim still rejected on its own terms');
+      },
+    },
     {
       name: 'quads peeks/1 supplies one unconsumed look-ahead character (issue #62)',
       run: () => {