eyeprolog 1.3.91 → 1.3.93

package/src/solver.js

@@ -1371,7 +1371,14 @@ function groupNeedsActiveFrame(group) {
   return group.cutReachable !== false || (group.recursive && !group.linearNumeric);
 }
 
-function* datalogAnswerSolutions(solver, relation, goal, env) {
+function datalogAnswerSolutions(solver, relation, goal, env) {
+  const state = { pending: false };
+  const iterator = datalogAnswerGenerator(solver, relation, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* datalogAnswerGenerator(solver, relation, goal, env, state) {
   if (!relation) return;
   const candidates = datalogCandidateIndexes(
     relation,
@@ -1380,20 +1387,26 @@ function* datalogAnswerSolutions(solver, relation, goal, env) {
     derefForLocal,
     memoAnswerScalarKey,
   );
-  const visit = function* (rowIndex) {
+  const indexes = candidates == null
+    ? { length: relation.rows.length, at: (index) => index }
+    : { length: candidates.length, at: (index) => candidates[index] };
+  for (let position = 0; position < indexes.length; position++) {
+    const rowIndex = indexes.at(position);
     const row = relation.rows[rowIndex];
     const next = env.clone();
+    let matches = true;
     for (let i = 0; i < goal.arity; i++) {
       solver.stats.unify_calls++;
-      if (!unify(goal.args[i], row[i], next)) return;
+      if (!unify(goal.args[i], row[i], next)) {
+        matches = false;
+        break;
+      }
     }
+    if (!matches) continue;
+    state.pending = position + 1 < indexes.length;
     yield next;
-  };
-  if (candidates == null) {
-    for (let rowIndex = 0; rowIndex < relation.rows.length; rowIndex++) yield* visit(rowIndex);
-    return;
   }
-  for (const rowIndex of candidates) yield* visit(rowIndex);
+  state.pending = false;
 }
 
 function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active, solver) {
@@ -1428,7 +1441,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: false };
+  const iterator = bundledBetweenSolutions(solver, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
 function requireBetweenInteger(term, env) {
@@ -1440,7 +1456,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);
@@ -1457,8 +1473,12 @@ function* bundledBetweenSolutions(solver, goal, env) {
   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) {
@@ -1468,25 +1488,48 @@ function bundledMemberIterator(solver, group, goal, env) {
     return null;
   }
 
-  // Keep the relational/open-list cases in ordinary Prolog.  When the second
-  // argument is already a finite list, however, the canonical two-clause
-  // member/2 definition is exactly a left-to-right scan and can avoid clause
-  // freshening and recursive solver frames for every element.
-  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);
+  // Attributed and delayed list variables retain the ordinary clause path so
+  // their hooks and wake-up boundaries remain source-defined. Plain proper,
+  // partial, and improper lists can all follow the canonical two-clause
+  // relation lazily without first traversing the spine.
+  if (env._prologAttributes != null || env._delays != null) return null;
+  const state = { pending: false };
+  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], item, next)) yield next;
+    if (unify(goal.args[0], item, next)) {
+      // The tail itself is the pending search state. Do not inspect it for a
+      // future successful unification: an untried list position remains a
+      // choicepoint even when resuming it will eventually fail.
+      state.pending = isCons(cursor) || cursor.type === VAR;
+      yield next;
+    }
   }
+  if (cursor.type === VAR) {
+    const openTail = cursor;
+    const id = nextFreshId();
+    let candidate = cons(goal.args[0], variable(`__member${id}_tail`));
+    for (let before = 0n; ; before++) {
+      const next = env.clone();
+      solver.stats.unify_calls++;
+      if (unify(openTail, candidate, next)) {
+        state.pending = true;
+        yield next;
+      }
+      candidate = cons(variable(`__member${id}_head_${before}`), candidate);
+      generatedLengthAllocationCheckpoint(solver, before + 1n);
+    }
+  }
+  state.pending = false;
 }
 
 function bundledEllipsisPlan(solver, group, goal, rest, env) {
@@ -1520,7 +1563,7 @@ function bundledEllipsisPlan(solver, group, goal, rest, env) {
         if (output.type === VAR && continuationInput.type === VAR && output.name === continuationInput.name &&
             output.name.startsWith('\u0000dcg')) {
           return {
-            iterator: bundledEllipsisSolutions(solver, continuation.args[1], input, env),
+            iterator: bundledEllipsisIterator(solver, continuation.args[1], input, env),
             rest: rest.slice(1),
           };
         }
@@ -1528,7 +1571,14 @@ function bundledEllipsisPlan(solver, group, goal, rest, env) {
     }
   }
 
-  return { iterator: bundledEllipsisSolutions(solver, goal.args[1], input, env), rest };
+  return { iterator: bundledEllipsisIterator(solver, goal.args[1], input, env), rest };
+}
+
+function bundledEllipsisIterator(solver, output, input, env) {
+  const state = { pending: false };
+  const iterator = bundledEllipsisSolutions(solver, output, input, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
 function isBinaryIdentityGroup(group) {
@@ -1548,7 +1598,7 @@ function isBinaryIdentityGroup(group) {
     (a.name === right.name && b.name === left.name);
 }
 
-function* bundledEllipsisSolutions(solver, output, input, env) {
+function* bundledEllipsisSolutions(solver, output, input, env, state) {
   let cursor = input;
   const requestedOutput = deref(output, env);
 
@@ -1568,7 +1618,10 @@ function* bundledEllipsisSolutions(solver, output, input, env) {
   while (true) {
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(output, cursor, next)) yield next;
+    if (unify(output, cursor, next)) {
+      state.pending = isCons(cursor);
+      yield next;
+    }
     if (isEmptyList(cursor)) return;
     if (!isCons(cursor)) return;
     cursor = deref(cursor.args[1], env);
@@ -1601,7 +1654,14 @@ function bundledLengthIterator(solver, group, goal, env) {
       if (length.type === VAR && cursor.name === length.name) return null;
     }
   }
-  return bundledLengthSolutions(solver, goal, env);
+  const state = {
+    // length(OpenList, Length) has an unbounded succession of longer lists.
+    // All other accepted fast-path modes are semidet.
+    pending: length.type === VAR && cursor.type === VAR,
+  };
+  const iterator = bundledLengthSolutions(solver, goal, env);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
 function* bundledLengthSolutions(solver, goal, env) {
@@ -2185,7 +2245,14 @@ function pushStreamingScalarFactRun(stack, solver, runGoals, groups, rest, env,
   });
 }
 
-function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
+function scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
+  const state = { pending: false };
+  const iterator = scalarFactRunGenerator(solver, goals, groups, env, depth, active, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* scalarFactRunGenerator(solver, goals, groups, env, depth, active, pendingState) {
   const localStack = [{ index: 0, names: [], values: [] }];
   while (localStack.length) {
     const state = localStack.pop();
@@ -2194,6 +2261,7 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
       if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
+      pendingState.pending = localStack.length !== 0;
       yield next;
       continue;
     }
@@ -2218,6 +2286,7 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     for (let i = nextStates.length - 1; i >= 0; i--) localStack.push(nextStates[i]);
     if (solver.solutionsSeen >= solver.solutionLimit) return;
   }
+  pendingState.pending = false;
 }
 
 
@@ -2813,64 +2882,13 @@ function builtinIsReadyOrAuthoritative(def, solver, goal, env) {
 
 function iteratorMayHavePendingAlternatives(iterator) {
   const predicate = iterator?.hasPendingAlternatives;
-  return typeof predicate === 'function' && predicate.call(iterator) !== false;
-}
-
-function lookaheadChoiceIterator(iterator) {
-  let buffered = null;
-  let bufferedReady = false;
-  let closed = false;
-
-  const fill = () => {
-    if (closed || bufferedReady) return;
-    buffered = iterator.next();
-    bufferedReady = true;
-    if (buffered.done) closed = true;
-  };
-
-  return {
-    next() {
-      fill();
-      if (buffered?.done !== false) return buffered ?? { done: true, value: undefined };
-      const result = buffered;
-      buffered = null;
-      bufferedReady = false;
-      // Ordinary relational iterators are advanced by one answer so their
-      // exhausted state is known before this answer reaches the caller.
-      fill();
-      return result;
-    },
-    return(value) {
-      if (!closed) iterator.return?.();
-      closed = true;
-      buffered = { done: true, value };
-      bufferedReady = true;
-      return buffered;
-    },
-    throw(error) {
-      closed = true;
-      if (typeof iterator.throw === 'function') return iterator.throw(error);
-      throw error;
-    },
-    prepareClose(reason) {
-      iterator.prepareClose?.(reason);
-    },
-    hasPendingAlternatives() {
-      fill();
-      return buffered?.done === false;
-    },
-    [Symbol.iterator]() { return this; },
-  };
-}
-
-function choicepointAwareIterator(iterator) {
-  return typeof iterator?.hasPendingAlternatives === 'function'
-    ? iterator
-    : lookaheadChoiceIterator(iterator);
+  // An unannotated suspended iterator is itself an untried continuation.
+  // Advancing it here would speculatively execute Prolog search (and possibly
+  // effects) merely to discover whether a later answer succeeds.
+  return typeof predicate !== 'function' || predicate.call(iterator) !== false;
 }
 
 function pushResumeBuiltinFrame(stack, iterator, goals, depth, active) {
-  iterator = choicepointAwareIterator(iterator);
   if (!iteratorMayHavePendingAlternatives(iterator)) {
     // Finish the suspended generator now so its finally blocks release child
     // solvers, aggregate statistics, and perform predicate-local cleanup.

package/src/standard-library.js

@@ -274,7 +274,14 @@ function* statisticsBuiltin({ solver, env }) {
   yield env;
 }
 
-function* statisticsValueBuiltin({ solver, goal, env }) {
+function statisticsValueBuiltin(context) {
+  const state = { pending: false };
+  const iterator = statisticsValueSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* statisticsValueSolutions({ solver, goal, env }, state) {
   const snapshot = runtimeStatistics(solver);
   const key = deref(goal.args[0], env);
   const entries = key.type === VAR
@@ -288,10 +295,15 @@ function* statisticsValueBuiltin({ solver, goal, env }) {
     throw new PrologError('domain_error(statistics_key)', key);
   }
 
-  for (const [name, value] of entries) {
+  for (let index = 0; index < entries.length; index++) {
+    const [name, value] = entries[index];
     const next = env.clone();
-    if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], numberTerm(value), next)) yield next;
+    if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], numberTerm(value), next)) {
+      state.pending = index + 1 < entries.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 export function createEyePrologRegistry() {

package/src/term.js

@@ -65,7 +65,7 @@ export class CompactListTerm {
     }
     return this._args;
   }
-  mayContainVariable(name) {
+  mayContainVariable(name, env = null) {
     if (String(name).startsWith(this._variablePrefix)) {
       const indexText = String(name).slice(this._variablePrefix.length);
       if (/^\d+$/.test(indexText)) {
@@ -73,9 +73,12 @@ export class CompactListTerm {
         if (index >= this._offset && index < this._offset + this._compactLength) return true;
       }
     }
-    // If no generated head in this suffix has ever participated in a binding,
-    // an unrelated variable cannot occur below it. This remains conservative
-    // across backtracking because the high-water mark is never rolled back.
+    // An Env keeps the exact backtrackable set of cells whose current values
+    // may reach an external variable. Without one, retain the shared
+    // high-water mark as a conservative public-API fallback.
+    if (env?.compactListMayReachExternalVariable != null) {
+      return env.compactListMayReachExternalVariable(this._compactState, this._offset);
+    }
     return this._compactState.maxPossiblyBoundIndex >= this._offset;
   }
 }
@@ -124,6 +127,11 @@ export class Env {
     this._backtrackableBlackboard = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
+    // Origins carried by variables that temporarily represent compact-list
+    // cells. Indexed by logical variable name because callers may reconstruct
+    // an equivalent Term object while environments retain name identity.
+    this._compactVariableOrigins = null;
+    this._compactVariableRisks = null;
   }
   clone() {
     // Most speculative environments are either rejected without a binding or
@@ -142,6 +150,8 @@ export class Env {
     clone._backtrackableBlackboard = this._backtrackableBlackboard;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
+    clone._compactVariableOrigins = this._compactVariableOrigins;
+    clone._compactVariableRisks = this._compactVariableRisks;
     return clone;
   }
   setOccursCheckHandler(handler) {
@@ -164,8 +174,80 @@ export class Env {
     // Execution callbacks belong to the Solver driving this Env, not to the
     // logical branch being adopted from an inner attribute-hook call.
     this._localVariables = other._localVariables;
+    this._compactVariableOrigins = other._compactVariableOrigins;
+    this._compactVariableRisks = other._compactVariableRisks;
     return this;
   }
+  compactVariableOrigins(name) {
+    return this._compactVariableOrigins?.get(name) ?? null;
+  }
+  transferCompactVariableOrigins(sourceName, targetName, origins) {
+    const next = new Map(this._compactVariableOrigins ?? []);
+    if (sourceName !== targetName) next.delete(sourceName);
+    next.set(targetName, origins);
+    this._compactVariableOrigins = next.size === 0 ? null : next;
+  }
+  removeCompactVariableOrigins(name) {
+    if (this._compactVariableOrigins?.has(name) !== true) return;
+    const next = new Map(this._compactVariableOrigins);
+    next.delete(name);
+    this._compactVariableOrigins = next.size === 0 ? null : next;
+  }
+  addCompactVariableRisks(origins) {
+    if (origins.length === 0) return;
+    const next = new Map(this._compactVariableRisks ?? []);
+    for (const { state, index } of origins) {
+      const current = next.get(state) ?? null;
+      let top = current?.top ?? null;
+      const removed = current?.removed ?? null;
+      while (top != null && removed?.has(top)) top = top.parent;
+      // Immediate variable-to-variable handoffs carry the same origin. Avoid
+      // stacking duplicate risk entries along that common alias chain.
+      if (top?.index === index) continue;
+      next.set(state, { top: { index, parent: top }, removed });
+    }
+    this._compactVariableRisks = next;
+  }
+  removeCompactVariableRisks(origins) {
+    if (origins.length === 0 || this._compactVariableRisks == null) return;
+    const next = new Map(this._compactVariableRisks);
+    for (const { state, index } of origins) {
+      const current = next.get(state);
+      if (current == null) continue;
+      let top = current.top;
+      let removed = current.removed;
+      while (top != null && removed?.has(top)) top = top.parent;
+      if (top?.index === index) {
+        top = top.parent;
+        while (top != null && removed?.has(top)) top = top.parent;
+      } else {
+        // Out-of-order handoffs are uncommon, but remain exact: tombstone
+        // every active entry for this origin without rewriting the persistent
+        // stack shared by sibling environments.
+        let scan = top;
+        let changed = false;
+        while (scan != null) {
+          if (scan.index === index && removed?.has(scan) !== true) {
+            if (!changed) removed = new Set(removed ?? []);
+            removed.add(scan);
+            changed = true;
+          }
+          scan = scan.parent;
+        }
+      }
+      if (top == null) next.delete(state);
+      else next.set(state, { top, removed });
+    }
+    this._compactVariableRisks = next.size === 0 ? null : next;
+  }
+  compactListMayReachExternalVariable(state, offset) {
+    const current = this._compactVariableRisks?.get(state);
+    if (current == null) return false;
+    for (let entry = current.top; entry != null; entry = entry.parent) {
+      if (current.removed?.has(entry) !== true && entry.index >= offset) return true;
+    }
+    return false;
+  }
   getBacktrackableBlackboard(key) {
     return this._backtrackableBlackboard?.get(key);
   }
@@ -605,7 +687,7 @@ function occursUncached(variableName, term, env) {
       if (binding !== undefined) stack.push(binding);
       continue;
     }
-    if (isCompactList(current) && !current.mayContainVariable(variableName)) continue;
+    if (isCompactList(current) && !current.mayContainVariable(variableName, env)) continue;
     if (current?.type !== COMPOUND || seenTerms.has(current)) continue;
     seenTerms.add(current);
     for (let i = 0; i < current.arity; i++) stack.push(current.args[i]);
@@ -693,11 +775,11 @@ export function unify(left, right, env, options = {}) {
       const aLocalDcg = env?.isLocalVariable(a.name) === true &&
         a.name.startsWith('\u0000dcg') && b.name.startsWith('\u0000dcg');
       if (aLocalDcg) {
-        markCompactVariableBound(b);
+        transferCompactVariableOrigins(b, a, env);
         env?.finalizePrologAttributeAlias?.(b.name, a.name);
         env.bind(b.name, a);
       } else {
-        markCompactVariableBound(a);
+        transferCompactVariableOrigins(a, b, env);
         env?.finalizePrologAttributeAlias?.(a.name, b.name);
         env.bind(a.name, b);
       }
@@ -715,7 +797,7 @@ export function unify(left, right, env, options = {}) {
         b = deref(b, env);
         if (a.type !== VAR) { stack.push([a, b]); continue; }
       }
-      markCompactVariableBound(a);
+      markCompactVariableBound(a, b, env);
       env?.dropPrologAttributes?.(a.name);
       env.bind(a.name, b);
       if (aLocal) env.forgetLocalVariable(a.name);
@@ -733,7 +815,7 @@ export function unify(left, right, env, options = {}) {
         a = deref(a, env);
         if (b.type !== VAR) { stack.push([a, b]); continue; }
       }
-      markCompactVariableBound(b);
+      markCompactVariableBound(b, a, env);
       env?.dropPrologAttributes?.(b.name);
       env.bind(b.name, a);
       if (bLocal) env.forgetLocalVariable(b.name);
@@ -761,10 +843,50 @@ export function unify(left, right, env, options = {}) {
   return true;
 }
 
-function markCompactVariableBound(term) {
-  if (term?._compactState == null || term._compactIndex == null) return;
-  if (term._compactIndex > term._compactState.maxPossiblyBoundIndex) {
-    term._compactState.maxPossiblyBoundIndex = term._compactIndex;
+function compactVariableOrigins(term, env) {
+  const remembered = term?.type === VAR ? env?.compactVariableOrigins(term.name) : null;
+  const origins = remembered == null ? [] : [...remembered];
+  if (term?._compactState != null && term._compactIndex != null &&
+      !origins.some(({ state, index }) => state === term._compactState && index === term._compactIndex)) {
+    origins.push({ state: term._compactState, index: term._compactIndex });
+  }
+  return origins;
+}
+
+function transferCompactVariableOrigins(source, target, env) {
+  const sourceOrigins = compactVariableOrigins(source, env);
+  if (sourceOrigins.length === 0 || target?.type !== VAR) return;
+  const targetOrigins = compactVariableOrigins(target, env);
+  for (const origin of sourceOrigins) {
+    if (!targetOrigins.some(({ state, index }) => state === origin.state && index === origin.index)) {
+      targetOrigins.push(origin);
+    }
+  }
+  env?.addCompactVariableRisks(sourceOrigins);
+  env?.transferCompactVariableOrigins(source.name, target.name, targetOrigins);
+}
+
+function markCompactVariableBound(term, value, env) {
+  const origins = compactVariableOrigins(term, env);
+  if (origins.length === 0) return;
+  // A compact cell commonly passes through a fresh clause variable before it
+  // receives its actual value. Carry the provenance along that alias. Only a
+  // non-scalar value can make an unrelated logical variable reachable from
+  // the compact list, so ground atoms and numbers need not poison the whole
+  // suffix for subsequent finite-tree occurs checks.
+  if (value?.type === VAR) {
+    transferCompactVariableOrigins(term, value, env);
+    return;
+  }
+  if (isScalar(value)) {
+    env?.removeCompactVariableRisks(origins);
+    env?.removeCompactVariableOrigins(term.name);
+    return;
+  }
+  env?.addCompactVariableRisks(origins);
+  env?.removeCompactVariableOrigins(term.name);
+  for (const { state, index } of origins) {
+    if (index > state.maxPossiblyBoundIndex) state.maxPossiblyBoundIndex = index;
   }
 }