eyeprolog 1.3.94 → 1.3.96

package/examples/book/README.md

@@ -238,12 +238,13 @@ npm run generate
 
 ## Chapter 39: Built-in predicates by programming role
 
-- [01-answer.pl](chapter-39/01-answer.pl) — The EyeProlog library
-- [02-answer-2.pl](chapter-39/02-answer-2.pl)
-- [03-answer-3.pl](chapter-39/03-answer-3.pl)
-- [04-cost.pl](chapter-39/04-cost.pl)
-- [05-message.pl](chapter-39/05-message.pl)
-- [06-task.pl](chapter-39/06-task.pl)
+- [01-program.pl](chapter-39/01-program.pl) — The EyeProlog library
+- [02-answer.pl](chapter-39/02-answer.pl)
+- [03-answer-2.pl](chapter-39/03-answer-2.pl)
+- [04-answer-3.pl](chapter-39/04-answer-3.pl)
+- [05-cost.pl](chapter-39/05-cost.pl)
+- [06-message.pl](chapter-39/06-message.pl)
+- [07-task.pl](chapter-39/07-task.pl)
 
 ## Chapter 40: Running EyeProlog: command line and corpus
 

package/examples/book/chapter-39/01-program.pl

@@ -0,0 +1,4 @@
+% From The Art of EyeProlog, Chapter 39 — The EyeProlog library.
+?- dif(f(X,A),f(Y,B)), ( true ; A = B ).
+   dif(f(X, A), f(Y, B))
+;  A = B, dif(X, Y).

package/examples/book/chapter-39/{01-answer.pl → 02-answer.pl}

@@ -1,4 +1,4 @@
-% From The Art of EyeProlog, Chapter 39 — The EyeProlog library.
+% From The Art of EyeProlog, Chapter 39.
 :- use_module(library(dates)).
 :- use_module(library(between), [between/3]).
 :- use_module(library(random)).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.94",
+  "version": "1.3.96",
   "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

@@ -400,6 +400,20 @@ function regressionCases() {
           'dif/2 residuals are minimal without auxiliary terms');
         assertEqual(residuals.stderr, '', 'dif/2 normalization display stderr');
 
+        const perfection = runCli([], {
+          input:
+            'dif(f(X,A),f(Y,B)), ( true ; A = B ).\n' +
+            ';\n' +
+            'halt.\n',
+        });
+        assertEqual(perfection.status, 0, 'dif/2 branch-local projection status');
+        assertEqual(perfection.stdout,
+          '?-    dif(f(X, A), f(Y, B))\n' +
+          ';  A = B, dif(X, Y).\n' +
+          '?- ',
+          'dif/2 residual projection is re-evaluated after branch-local bindings');
+        assertEqual(perfection.stderr, '', 'dif/2 branch-local projection stderr');
+
         const pendingDifCount = (text) => {
           const solver = new Solver(Program.parse(''), { registry: getEyePrologRegistry() });
           const solutions = solver.solve([parseGoalText(text)], new Env(), 0);
@@ -951,6 +965,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

@@ -6293,7 +6293,15 @@ answers `Y=1`, `Y=2`, and `Y=3`.
 can still unify. Its residual store is normalized by logical implication:
 symmetric or equivalent constraints share one residual, and a stronger
 constraint removes weaker ones regardless of insertion order. Independent
-disequalities remain separate.
+disequalities remain separate. Residual projection is re-evaluated in each
+solution environment, so a compound disequality is kept intact until later
+bindings make one aligned subterm pair sufficient. For example:
+
+```eyeprolog
+?- dif(f(X,A),f(Y,B)), ( true ; A = B ).
+   dif(f(X, A), f(Y, B))
+;  A = B, dif(X, Y).
+```
 
 <!-- eyeprolog-library-catalog:start -->
 
@@ -7045,8 +7053,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