eyeprolog 1.3.94 → 1.3.95

package/package.json

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

package/src/quads.js

@@ -152,17 +152,25 @@ function checkAlternative(program, quad, alternative, options, context) {
     // portably outlaw the implementation's chosen STO outcome. This is the
     // case behind issue #60's `false, unexpected` example.
     const stoPermitsUnexpected = context.declaresSto && actual.stoObserved && leaf.unexpected && !leaf.sto;
-    if (!stoPermitsUnexpected && (leaf.unexpected ? matches : !matches)) {
+    if (leaf.unexpected) {
+      // `unexpected` is a negative assertion about the leaf at this answer
+      // position.  Once the observed answer differs, the assertion is proved;
+      // it does not consume that answer or require the query to end afterward.
+      // Likewise, an STO-declared query may accept an implementation-dependent
+      // answer at this point without imposing any later answer-sequence check.
+      if (stoPermitsUnexpected) return { ok: true };
+      if (matches) return { ok: false };
+      if (actual.undecided && leafNeedsMoreSearch(leaf, actual, position)) {
+        return undecidedResult(actual, alternative);
+      }
+      return { ok: true };
+    }
+    if (!matches) {
       if (actual.undecided && leafNeedsMoreSearch(leaf, actual, position)) {
         return undecidedResult(actual, alternative);
       }
       return { ok: false };
     }
-    // An unexpected error description is a negative assertion about that
-    // particular error pattern.  A different exception may be present and is
-    // checked by other descriptions; do not make the final 'no error' test
-    // turn a successful negative match back into a failure.
-    if (leaf.unexpected && leaf.error != null) return { ok: true };
     if (leaf.more) return { ok: true };
     if (!leaf.unexpected && (leaf.false || leaf.loops || leaf.error != null)) {
       if (actual.undecided) return undecidedResult(actual, alternative);

package/test/run-regression.mjs

@@ -951,6 +951,64 @@ why(
         assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads treats unexpected as a negative assertion on the next leaf (issue #83)',
+      run: () => {
+        const source = `:- use_module(library(prologue)).
+` +
+          `40
+` +
+          `?- member(X,"abc").
+` +
+          `   X = a
+` +
+          `;  X = b
+` +
+          `;  X = c.
+` +
+          `   X = a
+` +
+          `;  X = c, unexpected.
+
+` +
+          `41
+` +
+          `?- member(X, Xs).
+` +
+          `   Xs = [X|_A]
+` +
+          `;  ... .
+` +
+          `   Xs = [X|_A]
+` +
+          `;  Xs = [_A,X|_B]
+` +
+          `;  Xs = [_A,_B,X|_C]
+` +
+          `;  ... .
+` +
+          `   Xs = [X|_A]
+` +
+          `;  Xs = [], unexpected.
+`;
+        const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'unexpected-quad.pl' }]));
+        assertEqual(result.total, 5, 'quad total');
+        assertEqual(result.passed, 5, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 5 run, 5 passed, 0 failed.\n', 'quad report');
+
+        const forbidden = publicApi.runQuads(`:- use_module(library(prologue)).
+` +
+          `?- member(X,[a,c]).
+` +
+          `   X = a
+` +
+          `;  X = c, unexpected.
+`);
+        assertEqual(forbidden.total, 1, 'forbidden next answer total');
+        assertEqual(forbidden.failed, 1, 'matching unexpected next answer fails');
+      },
+    },
     {
       name: 'runQuads distinguishes query variables from renamed throw variables',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -7045,8 +7045,12 @@ accepted as a negative answer.
 Answer descriptions support ordered answers separated by `;`, acceptable
 alternatives separated by `|`, `true`, `false`, standard error descriptions,
 and the `unexpected` annotation for an answer that must not occur (`inattendue`
-is its synonym). Variables named in the query keep their identity inside answer
-descriptions; variables introduced only by a description are fresh. For example,
+is its synonym). In an ordered answer sequence, `unexpected` is a negative
+assertion about the answer at that position: once the next observed answer does
+not match the annotated leaf, that description succeeds and does not require the
+query to have no further answers. Variables named in the query keep their
+identity inside answer 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. The `maybe` annotation describes