eyeprolog 1.3.93 → 1.3.95

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.93",
+  "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/src/solver.js

@@ -524,14 +524,21 @@ export class Solver {
         if (this.solutionsSeen >= this.solutionLimit) break;
 
         const pendingAttributeGoals = env.takePendingAttributeGoals?.() ?? [];
-        if (pendingAttributeGoals.length > 0) goals = [...pendingAttributeGoals, ...goals];
+        if (pendingAttributeGoals.length > 0) {
+          // Goals produced by verify_attributes/3 are invoked by the attribute
+          // mechanism, not textually spliced into the caller.  Give every
+          // awakened goal the same opaque cut boundary as call/1 so a delayed
+          // cut cannot prune choices that were made before the suspension.
+          const awakened = pendingAttributeGoals.map((pending) => compound('call', [pending]));
+          goals = [...awakened, ...goals];
+        }
 
         const readyDelays = env.takeReadyDelays();
         if (readyDelays.length > 0) {
           const awakened = readyDelays.map(({ goal, module }) => {
             const delayed = copyResolved(goal, env);
             qualifyTerm(delayed, module);
-            return delayed;
+            return compound('call', [delayed]);
           });
           goals = [...awakened, ...goals];
         }

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: () => {
@@ -1990,6 +2048,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'wake(ready, awake).\n', 'freeze answer');
       },
     },
+    {
+      name: 'Prologue freeze keeps awakened cuts inside the delayed call (issue #81)',
+      run: () => {
+        const result = publicApi.runQuads(`:- use_module(library(prologue)).
+38
+?- call( ( (Y=1;Y=2), freeze(X,!), X = c ) ); Y = 3.
+   Y = 1, X = c
+;  Y = 2, X = c
+;  Y = 3.
+`);
+        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');
+      },
+    },
     {
       name: 'runQuads covers the remaining finite Prologue examples and arities',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -6283,7 +6283,11 @@ private helpers and same-named predicates in different modules separate.
 `freeze(?Term,:Goal)` runs `Goal` immediately when `Term` is already nonvariable;
 otherwise it delays the goal until `Term` becomes nonvariable. Suspensions are
 kept in the logical environment, so bindings and backtracking remain isolated
-between solution branches.
+between solution branches. When a suspension wakes, its goal is meta-invoked
+with its own cut scope: a `!` inside the delayed goal may commit choices made by
+that invocation, but it cannot prune alternatives that were created before the
+`freeze/2` call. Thus `call(((Y=1;Y=2),freeze(X,!),X=c));Y=3` retains the three
+answers `Y=1`, `Y=2`, and `Y=3`.
 
 `dif(?Left,?Right)` posts a delayed finite-tree disequality when its arguments
 can still unify. Its residual store is normalized by logical implication:
@@ -7041,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