eyeprolog 1.3.80 → 1.3.81

package/package.json

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

package/src/cleanup.js

@@ -5,7 +5,7 @@
 // therefore need two pieces of host support:
 //   * discarded resumeBuiltin iterators must be closed when search is pruned;
 //   * a cleanup iterator can report that its protected goal has no alternatives,
-//     so the REPL does not need speculative look-ahead to suppress a choicepoint.
+//     so the solver does not retain an exhausted resume frame.
 import { PrologError } from './errors.js';
 import { deref } from './term.js';
 
@@ -59,10 +59,6 @@ export function installCleanupLifecycle(Solver) {
       }
     }
   };
-
-  prototype.hasPendingAlternatives = function cleanupAwarePendingAlternatives() {
-    return this.solveStacks.some((stack) => stack.some(frameHasPendingAlternative));
-  };
 }
 
 export function registerCleanupBuiltins(registry) {
@@ -168,13 +164,6 @@ function closeFrames(frames, suppressErrors) {
   if (!suppressErrors && firstError != null) throw firstError;
 }
 
-function frameHasPendingAlternative(frame) {
-  if (frame?.kind !== 'resumeBuiltin') return true;
-  const predicate = frame.iterator?.hasPendingAlternatives;
-  if (typeof predicate !== 'function') return true;
-  return predicate.call(frame.iterator);
-}
-
 function callableTerm(term, env) {
   const value = deref(term, env);
   if (value.type === 'var') throw new PrologError('instantiation_error');

package/src/iso.js

@@ -2598,7 +2598,7 @@ function callResidueVarsBuiltin({ solver, goal, env }) {
   const child = solver.cloneForInnerGoal();
   let pending = true;
   // The wrapper iterator is resumable even for a deterministic Goal. Expose
-  // the child's actual search state so the top level does not print a phantom
+  // the child's actual search state so the solver does not install a phantom
   // choicepoint after the final answer.
   const iterator = (function* residueSolutions() {
     try {

package/src/solver.js

@@ -421,7 +421,11 @@ export class Solver {
         if (this.solutionsSeen >= this.solutionLimit) continue;
         const result = frame.iterator.next();
         if (result.done) continue;
-        stack.push(frame);
+        // Predicate iterators that can identify their final answer report it
+        // before yielding. Do not recreate a choicepoint that the predicate has
+        // already exhausted; consumers must not need to hide such a frame later.
+        if (iteratorMayHavePendingAlternatives(frame.iterator)) stack.push(frame);
+        else frame.iterator.return?.();
         stack.push({
           kind: 'goals',
           goals: frame.goals,
@@ -620,15 +624,7 @@ export class Solver {
             else this.stats.deterministic_builtin_failures++;
           }
           if (firstResult.done) break;
-          if (!deterministic) {
-            stack.push({
-              kind: 'resumeBuiltin',
-              iterator,
-              goals: rest,
-              depth: depth + 1,
-              active,
-            });
-          }
+          if (!deterministic) pushResumeBuiltinFrame(stack, iterator, rest, depth + 1, active);
           goals = rest;
           env = firstResult.value;
           depth++;
@@ -660,13 +656,7 @@ export class Solver {
           const iterator = datalogAnswerSolutions(this, relation, goal, env);
           const firstResult = iterator.next();
           if (firstResult.done) break;
-          stack.push({
-            kind: 'resumeBuiltin',
-            iterator,
-            goals: rest,
-            depth: depth + 1,
-            active,
-          });
+          pushResumeBuiltinFrame(stack, iterator, rest, depth + 1, active);
           goals = rest;
           env = firstResult.value;
           depth++;
@@ -683,13 +673,7 @@ export class Solver {
         if (betweenIterator != null) {
           const firstResult = betweenIterator.next();
           if (firstResult.done) break;
-          stack.push({
-            kind: 'resumeBuiltin',
-            iterator: betweenIterator,
-            goals: rest,
-            depth: depth + 1,
-            active,
-          });
+          pushResumeBuiltinFrame(stack, betweenIterator, rest, depth + 1, active);
           goals = rest;
           env = firstResult.value;
           depth++;
@@ -700,13 +684,7 @@ export class Solver {
         if (memberIterator != null) {
           const firstResult = memberIterator.next();
           if (firstResult.done) break;
-          stack.push({
-            kind: 'resumeBuiltin',
-            iterator: memberIterator,
-            goals: rest,
-            depth: depth + 1,
-            active,
-          });
+          pushResumeBuiltinFrame(stack, memberIterator, rest, depth + 1, active);
           goals = rest;
           env = firstResult.value;
           depth++;
@@ -717,13 +695,7 @@ export class Solver {
         if (lengthIterator != null) {
           const firstResult = lengthIterator.next();
           if (firstResult.done) break;
-          stack.push({
-            kind: 'resumeBuiltin',
-            iterator: lengthIterator,
-            goals: rest,
-            depth: depth + 1,
-            active,
-          });
+          pushResumeBuiltinFrame(stack, lengthIterator, rest, depth + 1, active);
           goals = rest;
           env = firstResult.value;
           depth++;
@@ -734,13 +706,7 @@ export class Solver {
         if (ellipsisPlan != null) {
           const firstResult = ellipsisPlan.iterator.next();
           if (firstResult.done) break;
-          stack.push({
-            kind: 'resumeBuiltin',
-            iterator: ellipsisPlan.iterator,
-            goals: ellipsisPlan.rest,
-            depth: depth + 1,
-            active,
-          });
+          pushResumeBuiltinFrame(stack, ellipsisPlan.iterator, ellipsisPlan.rest, depth + 1, active);
           goals = ellipsisPlan.rest;
           env = firstResult.value;
           depth++;
@@ -826,21 +792,12 @@ export class Solver {
   }
 
   hasPendingAlternatives(excludedStacks = null) {
-    // When solve() is suspended at an answer, active solve stacks contain
-    // unexplored work or an iterator frame that can prove it just yielded its
-    // final answer. The demand-driven REPL uses this without speculatively
-    // pulling the next answer. Control builtins can exclude their caller's
-    // pre-existing stacks when inspecting a nested branch.
-    return this.solveStacks.some((stack) => !excludedStacks?.has(stack) && stack.some((frame) => {
-      if (frame.kind === 'resumeBuiltin' &&
-          typeof frame.iterator?.hasPendingAlternatives === 'function') {
-        return frame.iterator.hasPendingAlternatives();
-      }
-      if (frame.kind === 'userClause' && headCannotMatch(frame.goal, frame.clause.head, frame.env)) {
-        return false;
-      }
-      return true;
-    }));
+    // Choicepoints are represented by actual pending frames. Predicate
+    // iterators discard an exhausted resume frame before yielding their final
+    // answer, so observers never need to reinterpret or conceal stack entries.
+    // Control builtins can exclude their caller's pre-existing stacks when
+    // inspecting a nested branch.
+    return this.solveStacks.some((stack) => !excludedStacks?.has(stack) && stack.length !== 0);
   }
 
   fastCountGoal(goal, env) {
@@ -2872,6 +2829,21 @@ function builtinIsReadyOrAuthoritative(def, solver, goal, env) {
   return !def.fallbackWhenNotReady;
 }
 
+function iteratorMayHavePendingAlternatives(iterator) {
+  const predicate = iterator?.hasPendingAlternatives;
+  return typeof predicate !== 'function' || predicate.call(iterator) !== false;
+}
+
+function pushResumeBuiltinFrame(stack, iterator, goals, depth, active) {
+  if (!iteratorMayHavePendingAlternatives(iterator)) {
+    // Finish the suspended generator now so its finally blocks release child
+    // solvers, aggregate statistics, and perform predicate-local cleanup.
+    iterator.return?.();
+    return;
+  }
+  stack.push({ kind: 'resumeBuiltin', iterator, goals, depth, active });
+}
+
 function selectReadyDeterministicBuiltin(goals, env, registry) {
   for (let i = 0; i < goals.length; i++) {
     const goal = goals[i];

package/test/run-regression.mjs

@@ -1827,7 +1827,7 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'REPL omits exhausted choicepoints without probing future branches (issue #74)',
+      name: 'predicates discard exhausted choicepoints before the REPL observes them (issue #74)',
       run: () => {
         const result = runCli([], {
           input:
@@ -1852,6 +1852,31 @@ c4 ?- call((!;1)).
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
 
+        const finalAnswerHasNoFrames = (source, text, answerCount, module = null) => {
+          const solver = new Solver(Program.parse(source), { registry: getEyePrologRegistry() });
+          const goal = parseGoalText(text);
+          if (module != null) goal.module = module;
+          const solutions = solver.solve([goal], new Env(), 0);
+          for (let answer = 1; answer <= answerCount; answer++) {
+            assertEqual(solutions.next().done, false, `${text} answer ${answer}`);
+            if (answer < answerCount) {
+              assertEqual(solver.solveStacks.some((stack) => stack.length !== 0), true,
+                `${text} retains its genuine earlier choicepoint`);
+            }
+          }
+          assertEqual(solver.solveStacks.every((stack) => stack.length === 0), true,
+            `${text} removes its exhausted predicate frames`);
+          assertEqual(solver.hasPendingAlternatives(), false,
+            `${text} has no reported alternatives`);
+          solutions.return();
+        };
+
+        finalAnswerHasNoFrames('', 'X=1;X=2', 2);
+        finalAnswerHasNoFrames('', 'setof(X,true,Xs)', 1);
+        finalAnswerHasNoFrames('', 'findall(t,false,Xs)', 1);
+        finalAnswerHasNoFrames(':- use_module(library(lists)).', 'member(a,"ba")', 1, 'lists');
+        finalAnswerHasNoFrames(':- use_module(library(lists)).', 'append("a",Xs,Xs0)', 1, 'lists');
+
         const grouped = new Solver(Program.parse(''));
         const groupedSolutions = grouped.solve([
           parseGoalText('setof(X,(Y=1,X=a;Y=2,X=b),Xs)'),