eyeprolog 1.5.28 → 1.5.29

package/package.json

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

package/src/iso.js

@@ -860,7 +860,7 @@ function* retractSolutions({ solver, goal, env }, state) {
     if (!unify(parts.head, copied.args[0], next)) continue;
     if (parts.rule && !unify(parts.body, copied.args[1], next)) continue;
     if (!parts.rule && !(copied.args[1].type === ATOM && copied.args[1].name === 'true')) continue;
-    matches.push({ clause, next });
+    matches.push({ clause, next: next._toPersistentEnv?.() ?? next });
   }
   for (let index = 0; index < matches.length; index++) {
     const { clause, next } = matches[index];

package/src/solver.js

@@ -392,6 +392,8 @@ export class Solver {
 
   *solve(goals, env = new Env(), depth = 0) {
     if (!Array.isArray(goals)) goals = [goals];
+    const ownsSolverBindings = env._isSolverEnv?.() !== true;
+    if (ownsSolverBindings) env = env._asSolverEnv();
     env.setOccursCheckHandler(this.occursCheckHandler);
     env.setAttributeHookRunner(this.attributeHookRunner);
     if (this.isoStrict) rejectStrictIsoStringTerms(goals, env);
@@ -437,6 +439,42 @@ export class Solver {
         });
         continue;
       }
+      if (frame.kind === 'unifyArgsBranch') {
+        if (this.solutionsSeen >= this.solutionLimit) continue;
+        const next = frame.env.clone();
+        const sourceArgs = frame.freshNonGround && !frame.args.every((arg) => termIsGround(arg))
+          ? freshTerm(compound('$branch_args', frame.args), nextFreshId()).args
+          : frame.args;
+        let ok = true;
+        for (let i = 0; i < frame.goal.arity; i++) {
+          this.stats.unify_calls++;
+          if (!unify(frame.goal.args[i], sourceArgs[i], next)) { ok = false; break; }
+        }
+        if (ok) {
+          stack.push({
+            kind: 'goals',
+            goals: frame.goals,
+            env: next,
+            depth: frame.depth,
+            active: frame.active,
+          });
+        }
+        continue;
+      }
+      if (frame.kind === 'bindBranch') {
+        if (this.solutionsSeen >= this.solutionLimit) continue;
+        const next = frame.env.clone();
+        for (let i = 0; i < frame.names.length; i++) next.bind(frame.names[i], frame.values[i]);
+        if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
+        stack.push({
+          kind: 'goals',
+          goals: frame.goals,
+          env: next,
+          depth: frame.depth,
+          active: frame.active,
+        });
+        continue;
+      }
       if (frame.kind === 'userClause') {
         if (this.solutionsSeen >= this.solutionLimit) continue;
         const { clause, goal: clauseGoal, rest: clauseRest, env: clauseEnv, depth: clauseDepth,
@@ -585,7 +623,7 @@ export class Solver {
           this.solutionsSeen++;
           this.stats.completed_goal_lists++;
           this.active = active;
-          yield env;
+          yield ownsSolverBindings && env._isSolverEnv?.() === true ? env._toPersistentEnv() : env;
           break;
         }
 
@@ -673,7 +711,7 @@ export class Solver {
           // pending exactly as they do for a direct call. A fresh active marker
           // keeps cut opaque at the call/N boundary.
           const expanded = def.expandGoal({ solver: this, goal, env });
-          const invocation = { goal, env };
+          const invocation = { goal, env: env._snapshotForSolverRead() };
           active = [...active, invocation];
           goals = [expanded, { kind: 'releaseActive' }, ...rest];
           depth++;
@@ -1096,12 +1134,12 @@ export class Solver {
     // expansion of the current rule body, but it must be released before
     // the caller's remaining goals are solved. Keeping the goal active
     // through rest goals over-prunes valid transitive/recursive derivations.
-    this.active.push({ goal, env: goalEnv });
+    this.active.push({ goal, env: goalEnv._snapshotForSolverRead() });
     for (const bodyEnv of this.solve(body, env, depth + 1)) {
       if (this.solutionsSeen > 0) this.solutionsSeen--;
       this.active.pop();
       yield* this.solve(rest, bodyEnv, depth + 1);
-      this.active.push({ goal, env: goalEnv });
+      this.active.push({ goal, env: goalEnv._snapshotForSolverRead() });
       if (this.solutionsSeen >= this.solutionLimit) break;
     }
     this.active.pop();
@@ -1231,25 +1269,24 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
       selected = { bucket, fallback, length: candidateLength };
     }
   }
-  const replay = (answerIndex) => {
-    const storedArgs = entry.answers[answerIndex];
-    const answerArgs = storedArgs.every((arg) => termIsGround(arg))
-      ? storedArgs
-      : freshTerm(compound('$memo_answer', storedArgs), nextFreshId()).args;
-    const next = env.clone();
-    let ok = true;
-    for (let i = 0; i < goal.arity; i++) {
-      solver.stats.unify_calls++;
-      if (!unify(goal.args[i], answerArgs[i], next)) { ok = false; break; }
-    }
-    if (ok) stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+  const pushReplay = (answerIndex) => {
+    stack.push({
+      kind: 'unifyArgsBranch',
+      goal,
+      args: entry.answers[answerIndex],
+      freshNonGround: true,
+      goals: rest,
+      env,
+      depth: depth + 1,
+      active,
+    });
   };
   if (selected != null) {
-    for (let i = selected.fallback.length - 1; i >= 0; i--) replay(selected.fallback[i]);
-    for (let i = selected.bucket.length - 1; i >= 0; i--) replay(selected.bucket[i]);
+    for (let i = selected.fallback.length - 1; i >= 0; i--) pushReplay(selected.fallback[i]);
+    for (let i = selected.bucket.length - 1; i >= 0; i--) pushReplay(selected.bucket[i]);
     return;
   }
-  for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) replay(answerIndex);
+  for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) pushReplay(answerIndex);
 }
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
@@ -1258,7 +1295,7 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
   const candidates = selectClauseCandidates(group, goal, env);
   const frames = [];
-  const invocation = { goal, env };
+  const invocation = { goal, env: env._snapshotForSolverRead() };
   // Active frames serve two purposes: they delimit cut and detect variants in
   // recursive user predicates. Cut-free, non-recursive library helpers need
   // neither. Copying their full active stack at every recursive step made
@@ -1535,18 +1572,20 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
   if (!relation) return;
   for (let rowIndex = relation.rows.length - 1; rowIndex >= 0; rowIndex--) {
     const row = relation.rows[rowIndex];
-    const next = env.clone();
-    let ok = true;
-    for (let i = 0; i < goal.arity; i++) {
-      solver.stats.unify_calls++;
-      if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
-    }
-    if (!ok) continue;
     if (!lower?.has(row)) {
       solver.stats.wfs_undefined_answers++;
       continue;
     }
-    stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
+    stack.push({
+      kind: 'unifyArgsBranch',
+      goal,
+      args: row,
+      freshNonGround: false,
+      goals: rest,
+      env,
+      depth: depth + 1,
+      active,
+    });
   }
 }
 
@@ -2030,14 +2069,8 @@ function termReferencesResolvedVariable(term, variableName, env) {
 }
 
 function envHasObservableAliasTo(variableName, env) {
-  for (let state = env?._state; state != null; state = state.parent) {
-    if (state.bindingName != null && state.bindingName !== variableName &&
-        termReferencesResolvedVariable(state.bindingValue, variableName, env)) return true;
-    if (state.bindings) {
-      for (const [name, value] of state.bindings) {
-        if (name !== variableName && termReferencesResolvedVariable(value, variableName, env)) return true;
-      }
-    }
+  for (const [name, value] of env?._bindingEntries?.() ?? []) {
+    if (name !== variableName && termReferencesResolvedVariable(value, variableName, env)) return true;
   }
   return false;
 }
@@ -2315,10 +2348,15 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     const state = localStack.pop();
     solver.stats.max_depth = Math.max(solver.stats.max_depth, state.depth);
     if (state.index === runLength) {
-      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;
-      frames.push({ kind: 'goals', goals: rest, env: next, depth: state.depth, active });
+      frames.push({
+        kind: 'bindBranch',
+        names: state.names,
+        values: state.values,
+        goals: rest,
+        env,
+        depth: state.depth,
+        active,
+      });
       if (frames.length > frameLimit) {
         // Do not repeat the old bug of abandoning the optimization and then
         // re-solving through the generic engine.  Restart this rare oversized

package/src/term.js

@@ -167,6 +167,15 @@ export class Env {
     this._attributeHookRunner = typeof handler === 'function' ? handler : null;
     return this;
   }
+  _asSolverEnv() {
+    return SolverEnv.from(this);
+  }
+  _isSolverEnv() {
+    return false;
+  }
+  _snapshotForSolverRead() {
+    return this.clone();
+  }
   adopt(other) {
     if (!(other instanceof Env)) throw new TypeError('Env.adopt expects Env');
     this._state = other._state;
@@ -333,6 +342,22 @@ export class Env {
     }
     return undefined;
   }
+  *_bindingEntries() {
+    const seen = new Set();
+    for (let state = this._state; state != null; state = state.parent) {
+      if (state.bindingName != null && !seen.has(state.bindingName)) {
+        seen.add(state.bindingName);
+        yield [state.bindingName, state.bindingValue];
+      }
+      if (state.bindings) {
+        for (const [name, value] of state.bindings) {
+          if (seen.has(name)) continue;
+          seen.add(name);
+          yield [name, value];
+        }
+      }
+    }
+  }
   compactForDeepContinuation(segmentLimit = 16) {
     if ((this._state.segmentCount ?? 0) < segmentLimit) return false;
     const flattened = new Map();
@@ -648,6 +673,227 @@ export class Env {
   }
 }
 
+
+class SolverBindingStore {
+  constructor(bindings) {
+    this.slots = new Map();
+    this.names = [];
+    this.values = [];
+    this.baseValues = [];
+    this.slotLastTrail = [];
+    this.freeSlots = [];
+    this.trailNames = [];
+    this.trailSlots = [];
+    this.trailOldValues = [];
+    this.trailNewValues = [];
+    this.trailPreviousForSlot = [];
+    this.trailCreated = [];
+    if (bindings != null) {
+      for (const [name, value] of bindings) {
+        const slot = this.names.length;
+        this.slots.set(name, slot);
+        this.names.push(name);
+        this.values.push(value);
+        this.baseValues.push(value);
+        this.slotLastTrail.push(-1);
+      }
+    }
+  }
+
+  mark() {
+    return this.trailSlots.length;
+  }
+
+  rollback(mark) {
+    if (mark > this.trailSlots.length) {
+      throw new Error('stale solver binding mark');
+    }
+    while (this.trailSlots.length > mark) {
+      const created = this.trailCreated.pop();
+      const previousForSlot = this.trailPreviousForSlot.pop();
+      this.trailNewValues.pop();
+      const oldValue = this.trailOldValues.pop();
+      const slot = this.trailSlots.pop();
+      const name = this.trailNames.pop();
+      this.slotLastTrail[slot] = previousForSlot;
+      if (created) {
+        this.slots.delete(name);
+        this.values[slot] = ENV_UNBOUND;
+        this.baseValues[slot] = ENV_UNBOUND;
+        this.names[slot] = null;
+        this.freeSlots.push(slot);
+      } else {
+        this.values[slot] = oldValue;
+      }
+    }
+  }
+
+  bind(name, value) {
+    let slot = this.slots.get(name);
+    const created = slot === undefined;
+    if (created) {
+      slot = this.freeSlots.length === 0 ? this.values.length : this.freeSlots.pop();
+      this.slots.set(name, slot);
+      this.names[slot] = name;
+      this.values[slot] = ENV_UNBOUND;
+      this.baseValues[slot] = ENV_UNBOUND;
+      this.slotLastTrail[slot] = -1;
+    }
+    const entry = this.trailSlots.length;
+    this.trailNames.push(name);
+    this.trailSlots.push(slot);
+    this.trailOldValues.push(this.values[slot]);
+    this.trailNewValues.push(value);
+    this.trailPreviousForSlot.push(this.slotLastTrail[slot] ?? -1);
+    this.trailCreated.push(created);
+    this.slotLastTrail[slot] = entry;
+    this.values[slot] = value;
+  }
+
+  getAtMark(name, mark) {
+    if (mark > this.trailSlots.length) throw new Error('stale solver binding mark');
+    const slot = this.slots.get(name);
+    if (slot === undefined) return undefined;
+    let entry = this.slotLastTrail[slot] ?? -1;
+    while (entry >= mark) entry = this.trailPreviousForSlot[entry] ?? -1;
+    const value = entry >= 0 ? this.trailNewValues[entry] : this.baseValues[slot];
+    return value === ENV_UNBOUND ? undefined : value;
+  }
+}
+
+function copyEnvBranchState(source, target) {
+  target._delays = source._delays;
+  target._variableConstraints = source._variableConstraints;
+  target._variableAnnotations = source._variableAnnotations;
+  target._prologAttributes = source._prologAttributes;
+  target._attributeHookRunner = source._attributeHookRunner;
+  target._pendingAttributeGoals = source._pendingAttributeGoals;
+  target._backtrackableBlackboard = source._backtrackableBlackboard;
+  target._occursCheckHandler = source._occursCheckHandler;
+  target._localVariables = source._localVariables;
+  target._compactVariableOrigins = source._compactVariableOrigins;
+  target._compactVariableRisks = source._compactVariableRisks;
+  return target;
+}
+
+class SolverEnvReadView {
+  constructor(source) {
+    this._solverBindings = source._solverBindings;
+    this._solverBindingMark = source._solverBindingMark;
+    this._localVariables = source._localVariables;
+  }
+  get(name) {
+    return this._solverBindings.getAtMark(name, this._solverBindingMark);
+  }
+  has(name) {
+    return this.get(name) !== undefined;
+  }
+  isLocalVariable(name) {
+    return this._localVariables?.has(name) === true;
+  }
+}
+
+// SolverEnv replaces persistent binding layers with one solver-owned mutable
+// slot store and a linear trail. Clones are just trail marks plus the existing
+// copy-on-write logical side stores. The solver explores these marks in depth-
+// first order, so rollback can discard unreachable branch history immediately.
+// Public Env remains persistent and is used for stable API snapshots.
+class SolverEnv extends Env {
+  constructor() {
+    super();
+    this._solverBindings = new SolverBindingStore();
+    this._solverBindingMark = 0;
+    this._state = null;
+  }
+
+  static from(env) {
+    if (env instanceof SolverEnv) return env;
+    const solverEnv = Object.create(SolverEnv.prototype);
+    solverEnv._state = null;
+    solverEnv._solverBindings = new SolverBindingStore(env?._bindingEntries?.() ?? []);
+    solverEnv._solverBindingMark = 0;
+    copyEnvBranchState(env ?? new Env(), solverEnv);
+    return solverEnv;
+  }
+
+  _asSolverEnv() {
+    return this;
+  }
+
+  _isSolverEnv() {
+    return true;
+  }
+
+  _snapshotForSolverRead() {
+    return new SolverEnvReadView(this);
+  }
+
+  _activateBindings() {
+    if (this._solverBindingMark !== this._solverBindings.trailSlots.length) {
+      this._solverBindings.rollback(this._solverBindingMark);
+    }
+  }
+
+  clone() {
+    this._activateBindings();
+    const clone = Object.create(SolverEnv.prototype);
+    clone._state = null;
+    clone._solverBindings = this._solverBindings;
+    clone._solverBindingMark = this._solverBindingMark;
+    return copyEnvBranchState(this, clone);
+  }
+
+  adopt(other) {
+    if (!(other instanceof Env)) throw new TypeError('Env.adopt expects Env');
+    if (other instanceof SolverEnv && other._solverBindings === this._solverBindings) {
+      other._activateBindings();
+      this._solverBindingMark = other._solverBindingMark;
+    } else {
+      const replacement = SolverEnv.from(other);
+      this._solverBindings = replacement._solverBindings;
+      this._solverBindingMark = replacement._solverBindingMark;
+    }
+    copyEnvBranchState(other, this);
+    return this;
+  }
+
+  has(name) {
+    return this.get(name) !== undefined;
+  }
+
+  get(name) {
+    this._activateBindings();
+    const slot = this._solverBindings.slots.get(name);
+    if (slot === undefined) return undefined;
+    const value = this._solverBindings.values[slot];
+    return value === ENV_UNBOUND ? undefined : value;
+  }
+
+  *_bindingEntries() {
+    this._activateBindings();
+    for (const [name, slot] of this._solverBindings.slots) {
+      const value = this._solverBindings.values[slot];
+      if (value !== ENV_UNBOUND) yield [name, value];
+    }
+  }
+
+  bind(name, term) {
+    this._activateBindings();
+    this._solverBindings.bind(name, term);
+    this._solverBindingMark = this._solverBindings.mark();
+  }
+
+  compactForDeepContinuation() {
+    return false;
+  }
+
+  _toPersistentEnv() {
+    const stable = new Env(this._bindingEntries());
+    copyEnvBranchState(this, stable);
+    return stable;
+  }
+}
+
 export function deref(term, env) {
   // Follow variable bindings until a non-variable term is reached. The seen set
   // protects readback from accidental cycles in partially constructed terms.