eyeprolog 1.5.88 → 1.5.89

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.88",
+  "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;
@@ -1010,15 +1025,22 @@ const FAILURE_LABELS = {
 function formatAlternativeContext(program, description, alternative) {
   const parts = splitOperator(description, '|');
   if (parts.length <= 1 || !parts.includes(alternative)) return null;
+  // 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 prefix = index === 0 ? '   ' : '|  ';
+    const marker = index === 0 ? '   ' : '|  ';
     if (part !== alternative) {
-      lines.push(`${prefix}...`);
+      lines.push(`${margin}${marker}...`);
       return;
     }
     splitOperator(part, ';').forEach((leaf, leafIndex) => {
-      lines.push(`${leafIndex === 0 ? prefix : ';  '}${formatQuadTerm(program, leaf)}`);
+      lines.push(`${margin}${leafIndex === 0 ? marker : ';  '}${formatQuadTerm(program, leaf)}`);
     });
   });
   // A trailing `...` glued straight to a full stop reads as four dots; the

package/test/regression/cases-regression.mjs

@@ -2586,13 +2586,16 @@ c4 ?- call((!;1)).
         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.
+        // 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,
-          '   ...\n' +
-          '|  sto, Xs = [E | Xs]\n' +
-          ';  Xs = [_A | _B], Ys = [E | Ys]\n' +
-          ';  ..., ad_infinitum\n' +
-          '|  ... .\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');
       },
@@ -2688,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: () => {