eyeprolog 1.3.77 → 1.3.78

package/package.json

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

package/src/iso.js

@@ -65,9 +65,9 @@ export const isoBuiltins = {
     registry.add('=..', 2, univBuiltin, { deterministic: true });
     registry.add('copy_term', 2, copyTermBuiltin, { deterministic: true });
     registry.add('term_variables', 2, termVariablesBuiltin, { deterministic: true });
-    registry.add('findall', 3, findallBuiltin);
-    registry.add('bagof', 3, bagofBuiltin);
-    registry.add('setof', 3, setofBuiltin);
+    registry.add('findall', 3, findallBuiltin, { deterministic: true });
+    registry.add('bagof', 3, bagofBuiltin, { deterministicWhen: allSolutionsHasAtMostOneGroup });
+    registry.add('setof', 3, setofBuiltin, { deterministicWhen: allSolutionsHasAtMostOneGroup });
     registry.add('clause', 2, clauseBuiltin, {
       shouldUse: ({ solver }) => solver.program.findGroup('clause', 2) == null,
     });
@@ -2367,6 +2367,16 @@ function allSolutionsBuiltin(asSet) {
 const bagofBuiltin = allSolutionsBuiltin(false);
 const setofBuiltin = allSolutionsBuiltin(true);
 
+function allSolutionsHasAtMostOneGroup({ goal, env }) {
+  try {
+    const { iterated, quantified } = bagGoalParts(goal.args[1], env);
+    return freeVariables(iterated, goal.args[0], quantified, env).length === 0;
+  } catch (_) {
+    // Leave error selection and reporting to the builtin itself.
+    return false;
+  }
+}
+
 function callable(term, env) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
@@ -2823,35 +2833,57 @@ function* negationBuiltin({ solver, goal, env }) {
   for (const _ of solver.cloneForInnerGoal(1).solve([invoked], env.clone(), 0)) return;
   yield env;
 }
-function* solveControlBranch(solver, goal, env) {
+function* solveControlBranch(solver, goal, env, observePending = null) {
+  const existingStacks = new Set(solver.solveStacks);
   for (const answer of solver.solve([callable(goal, env)], env, 0)) {
     // A branch answer is internal to its enclosing control construct. The
     // surrounding solve will count the completed control goal after the
     // builtin yields it. Leaving both counts in place makes a bounded search
     // such as once/1 or negation stop before it can observe the branch answer.
     if (solver.solutionsSeen > 0) solver.solutionsSeen--;
+    observePending?.(solver.hasPendingAlternatives(existingStacks));
     yield answer;
   }
 }
-function* disjunctionBuiltin({ solver, goal, env }) {
+function disjunctionBuiltin(context) {
+  const state = { pending: true };
+  const iterator = disjunctionSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+function* disjunctionSolutions({ solver, goal, env }, state) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
     for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(left.args[0], env)], env.clone(), 0)) {
-      yield* solveControlBranch(solver, left.args[1], conditionEnv);
+      yield* solveControlBranch(solver, left.args[1], conditionEnv,
+        (pending) => { state.pending = pending; });
+      state.pending = false;
       return;
     }
-    yield* solveControlBranch(solver, goal.args[1], env.clone());
+    yield* solveControlBranch(solver, goal.args[1], env.clone(),
+      (pending) => { state.pending = pending; });
+    state.pending = false;
     return;
   }
   const marker = solver.active[solver.active.length - 1] ?? null;
   const markerCutEpoch = marker?.cutEpoch ?? 0;
   const solverCutEpoch = solver.cutEpoch;
-  yield* solveControlBranch(solver, goal.args[0], env.clone());
+  yield* solveControlBranch(solver, goal.args[0], env.clone(), (pending) => {
+    const cutThisScope = marker == null
+      ? solver.cutEpoch !== solverCutEpoch
+      : (marker.cutEpoch ?? 0) !== markerCutEpoch;
+    state.pending = pending || !cutThisScope;
+  });
   const cutThisScope = marker == null
     ? solver.cutEpoch !== solverCutEpoch
     : (marker.cutEpoch ?? 0) !== markerCutEpoch;
-  if (cutThisScope) return;
-  yield* solveControlBranch(solver, goal.args[1], env.clone());
+  if (cutThisScope) {
+    state.pending = false;
+    return;
+  }
+  yield* solveControlBranch(solver, goal.args[1], env.clone(),
+    (pending) => { state.pending = pending; });
+  state.pending = false;
 }
 function* ifThenBuiltin({ solver, goal, env }) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
@@ -2875,6 +2907,7 @@ export class BuiltinRegistry {
       arity,
       handler,
       deterministic: options.deterministic ?? false,
+      deterministicWhen: options.deterministicWhen ?? null,
       ready: options.ready ?? null,
       fallbackWhenNotReady: options.fallbackWhenNotReady ?? false,
       shouldUse: options.shouldUse ?? null,

package/src/solver.js

@@ -607,14 +607,16 @@ export class Solver {
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
         if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
+          const deterministic = def.deterministic ||
+            def.deterministicWhen?.({ solver: this, goal, env }) === true;
           const iterator = def.handler({ solver: this, goal, env });
           const firstResult = iterator.next();
-          if (def.deterministic) {
+          if (deterministic) {
             if (!firstResult.done) this.stats.deterministic_builtin_successes++;
             else this.stats.deterministic_builtin_failures++;
           }
           if (firstResult.done) break;
-          if (!def.deterministic) {
+          if (!deterministic) {
             stack.push({
               kind: 'resumeBuiltin',
               iterator,
@@ -819,11 +821,22 @@ export class Solver {
     }
   }
 
-  hasPendingAlternatives() {
-    // When solve() is suspended at an answer, active solve stacks contain only
-    // unexplored work. The demand-driven REPL uses this without speculatively
-    // pulling the next answer.
-    return this.solveStacks.some((stack) => stack.length !== 0);
+  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;
+    }));
   }
 
   fastCountGoal(goal, env) {
@@ -1440,7 +1453,10 @@ function bundledBetweenIterator(solver, group, goal, env) {
   // the generated value in the caller repeatedly revisits all earlier frames.
   // Enumerate the canonical bundled relation directly while leaving user
   // definitions and non-EyeProlog registries on the ordinary Prolog path.
-  return bundledBetweenSolutions(solver, goal, env);
+  const state = { pending: true };
+  const iterator = bundledBetweenSolutions(solver, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
 function requireBetweenInteger(term, env) {
@@ -1452,7 +1468,7 @@ function requireBetweenInteger(term, env) {
   return BigInt(value.name);
 }
 
-function* bundledBetweenSolutions(solver, goal, env) {
+function* bundledBetweenSolutions(solver, goal, env, state) {
   const lower = requireBetweenInteger(goal.args[0], env);
   const upper = requireBetweenInteger(goal.args[1], env);
   const requested = deref(goal.args[2], env);
@@ -1462,15 +1478,23 @@ function* bundledBetweenSolutions(solver, goal, env) {
       throw new PrologError('type_error(integer)', requested);
     }
     const value = BigInt(requested.name);
-    if (value >= lower && value <= upper) yield env;
+    if (value >= lower && value <= upper) {
+      state.pending = false;
+      yield env;
+    }
+    state.pending = false;
     return;
   }
 
   for (let value = lower; value <= upper; value++) {
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[2], numberTerm(value), next)) yield next;
+    if (unify(goal.args[2], numberTerm(value), next)) {
+      state.pending = value < upper;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function bundledMemberIterator(solver, group, goal, env) {
@@ -1487,17 +1511,33 @@ function bundledMemberIterator(solver, group, goal, env) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) cursor = deref(cursor.args[1], env);
   if (!isEmptyList(cursor)) return null;
-  return bundledMemberSolutions(solver, goal, env);
+  const state = { pending: true };
+  const iterator = bundledMemberSolutions(solver, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
-function* bundledMemberSolutions(solver, goal, env) {
+function* bundledMemberSolutions(solver, goal, env, state) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) {
+    const item = cursor.args[0];
+    cursor = deref(cursor.args[1], env);
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[0], cursor.args[0], next)) yield next;
+    if (unify(goal.args[0], item, next)) {
+      state.pending = bundledMemberMayMatch(goal.args[0], cursor, env);
+      yield next;
+    }
+  }
+  state.pending = false;
+}
+
+function bundledMemberMayMatch(target, cursor, env) {
+  while (isCons(cursor)) {
+    if (!goalHeadTermsCannotMatch(target, cursor.args[0], env)) return true;
     cursor = deref(cursor.args[1], env);
   }
+  return false;
 }
 
 function bundledEllipsisPlan(solver, group, goal, rest, env) {
@@ -2849,11 +2889,22 @@ function headCannotMatch(goal, head, env) {
   if (goal.type !== COMPOUND || head.type !== COMPOUND) return false;
   if (goal.name !== head.name || goal.arity !== head.arity) return true;
   for (let i = 0; i < goal.arity; i++) {
-    const a = goal.args[i];
-    const b = head.args[i];
-    // Keep this only as a cheap scalar rejection. unify() remains authoritative.
-    const da = derefForLocal(a, env);
-    if (isScalarTerm(da) && isScalarTerm(b) && !sameScalarTerm(da, b)) return true;
+    if (goalHeadTermsCannotMatch(goal.args[i], head.args[i], env)) return true;
+  }
+  return false;
+}
+
+function goalHeadTermsCannotMatch(goalTerm, headTerm, env) {
+  const pending = [[goalTerm, headTerm]];
+  while (pending.length > 0) {
+    const [goalItem, headItem] = pending.pop();
+    const actual = derefForLocal(goalItem, env);
+    if (actual.type === VAR || headItem.type === VAR) continue;
+    if (actual.type !== headItem.type || actual.name !== headItem.name || actual.arity !== headItem.arity) return true;
+    if (actual.type !== COMPOUND) continue;
+    for (let index = 0; index < actual.arity; index++) {
+      pending.push([actual.args[index], headItem.args[index]]);
+    }
   }
   return false;
 }

package/test/run-regression.mjs

@@ -1826,6 +1826,41 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL omits exhausted choicepoints without probing future branches (issue #74)',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'X=1;X=2.\n;\n' +
+            'setof(X,true,Xs).\n' +
+            'findall(t,false,Xs).\n' +
+            'use_module(library(lists)).\n' +
+            'member(a,"ba").\n' +
+            'append("a",Xs,Xs0).\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    X = 1\n' +
+          ';  X = 2.\n' +
+          '?-    Xs = [_A].\n' +
+          '?-    Xs = [].\n' +
+          '?-    true.\n' +
+          '?-    true.\n' +
+          '?-    Xs0 = [a | Xs].\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+
+        const grouped = new Solver(Program.parse(''));
+        const groupedSolutions = grouped.solve([
+          parseGoalText('setof(X,(Y=1,X=a;Y=2,X=b),Xs)'),
+        ], new Env(), 0);
+        assertEqual(groupedSolutions.next().done, false, 'first grouped setof/3 answer');
+        assertEqual(grouped.hasPendingAlternatives(), true, 'genuine grouped setof/3 choicepoint');
+        groupedSolutions.return();
+      },
+    },
     {
       name: 'REPL hides aliases to fresh throw variables while preserving query aliases',
       run: () => {