eyeprolog 1.3.93 → 1.3.94

package/package.json

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

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

@@ -1990,6 +1990,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: