eyeprolog 1.3.74 → 1.3.76

package/package.json

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

package/src/iso.js

@@ -202,7 +202,12 @@ function difConstraint(left, right) {
     status(env) {
       if (identical(left, right, env)) return 'violated';
       const probe = env.clone();
-      return unify(left, right, probe, { skipVariableConstraints: true }) ? 'pending' : 'entailed';
+      // Test structural unifiability without waking freeze/2 or other
+      // attributed-variable hooks in this disposable environment.
+      return unify(left, right, probe, {
+        skipVariableConstraints: true,
+        skipAttributeHooks: true,
+      }) ? 'pending' : 'entailed';
     },
     residualGoal() {
       return compound('dif', [left, right]);
@@ -218,8 +223,12 @@ function* difBuiltin({ goal, env }) {
   // In EyeProlog's finite-tree model, terms that cannot unify are already
   // provably different and need no residual constraint. Otherwise attach a
   // disequality constraint to every currently unbound variable it mentions.
+  // This probe must not wake goals attached to those variables.
   const probe = env.clone();
-  if (!unify(left, right, probe, { skipVariableConstraints: true })) {
+  if (!unify(left, right, probe, {
+    skipVariableConstraints: true,
+    skipAttributeHooks: true,
+  })) {
     yield env;
     return;
   }
@@ -2556,19 +2565,32 @@ function residueVariablesSince(snapshot, env) {
   return names;
 }
 
-function* callResidueVarsBuiltin({ solver, goal, env }) {
+function callResidueVarsBuiltin({ solver, goal, env }) {
   const invoked = callable(goal.args[0], env);
   if (invoked.module == null) invoked.module = goal.module ?? 'user';
   const snapshot = residueSnapshot(env);
   const child = solver.cloneForInnerGoal();
-  try {
-    for (const answerEnv of child.solve([invoked], env, 0)) {
-      const next = answerEnv.clone();
-      if (unify(goal.args[1], listFromItems(residueVariablesSince(snapshot, answerEnv)), next)) yield next;
+  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
+  // choicepoint after the final answer.
+  const iterator = (function* residueSolutions() {
+    try {
+      for (const answerEnv of child.solve([invoked], env, 0)) {
+        pending = child.hasPendingAlternatives();
+        const next = answerEnv.clone();
+        if (unify(goal.args[1], listFromItems(residueVariablesSince(snapshot, answerEnv)), next)) {
+          yield next;
+          if (!pending) return;
+        }
+      }
+      pending = false;
+    } finally {
+      solver.absorbStatsFrom(child);
     }
-  } finally {
-    solver.absorbStatsFrom(child);
-  }
+  })();
+  iterator.hasPendingAlternatives = () => pending;
+  return iterator;
 }
 
 function* freezeBuiltin({ solver, goal, env }) {

package/src/repl.js

@@ -722,6 +722,12 @@ function formatAnswer(engine, state, variables, env) {
     : equality.specifier === 'xfy' ? equality.priority : equality.priority - 1;
   let generated = 0;
 
+  // Meta-predicate wrappers can make a query variable alias an internal fresh
+  // variable. Keep residual constraints tied to the query's visible name.
+  for (const variable of variables) {
+    const root = engine.deref(variable, env);
+    if (root.type === 'var' && !names.has(root.name)) names.set(root.name, variable.name);
+  }
   for (const variable of variables) collectUnboundVariables(engine, variable, env, names, () => `_${letterName(generated++)}`);
   for (const variable of variables) {
     const value = engine.deref(variable, env);

package/src/term.js

@@ -650,6 +650,7 @@ export function unify(left, right, env, options = {}) {
   // unification: a variable cannot be bound to a term containing itself.
   // Bindings are written into the supplied Env.
   const occursCheckHandler = options.occursCheck === 'fail' ? null : env?._occursCheckHandler;
+  const runAttributeHooks = options.skipAttributeHooks !== true;
   // Callers may provide a proof that selected variables cannot occur in the
   // term they are about to receive.  Source-level first-use analysis and a few
   // construction fast paths share this internal proof; ordinary unification
@@ -663,7 +664,7 @@ export function unify(left, right, env, options = {}) {
 
     if (a.type === VAR && b.type === VAR && a.name === b.name) continue;
     if (a.type === VAR && b.type === VAR) {
-      if (env?._prologAttributes != null) {
+      if (runAttributeHooks && env?._prologAttributes != null) {
         if (!env.preparePrologAttributeUnification(a, b)) return false;
         a = deref(a, env);
         b = deref(b, env);
@@ -694,7 +695,7 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(a, b, env);
         return false;
       }
-      if (env?._prologAttributes != null && env.hasPrologAttributes(a.name)) {
+      if (runAttributeHooks && env?._prologAttributes != null && env.hasPrologAttributes(a.name)) {
         if (!env.preparePrologAttributeUnification(a, b)) return false;
         a = deref(a, env);
         b = deref(b, env);
@@ -712,7 +713,7 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(b, a, env);
         return false;
       }
-      if (env?._prologAttributes != null && env.hasPrologAttributes(b.name)) {
+      if (runAttributeHooks && env?._prologAttributes != null && env.hasPrologAttributes(b.name)) {
         if (!env.preparePrologAttributeUnification(b, a)) return false;
         b = deref(b, env);
         a = deref(a, env);

package/test/run-regression.mjs

@@ -127,6 +127,17 @@ function regressionCases() {
           'scalar-fact fast matching still validates annotated variables');
         assertEqual(run('p(b).', { goal: 'dif(X,a),p(X)' }).stats.completed_goal_lists, 1,
           'scalar-fact fast matching can discharge an annotated disequality');
+
+        const freezeProgram = Program.parse(':- use_module(library(freeze), [freeze/2]).');
+        const freezeSolver = new Solver(freezeProgram);
+        const freezeDifGoal = parseGoalText('freeze(X,a),dif(X,c)');
+        const freezeDifAnswer = freezeSolver.solve([freezeDifGoal], new Env(), 0).next();
+        assertEqual(freezeDifAnswer.done, false, 'freeze/2 and dif/2 answer');
+        const freezeResiduals = freezeSolver.attributeResidualGoals(
+          freezeDifGoal.args[0].args[0], freezeDifAnswer.value,
+        );
+        assertEqual(freezeResiduals.length, 1,
+          'freeze/2 residual projection terminates alongside dif/2 (issue #73)');
       },
     },
     {
@@ -178,8 +189,19 @@ check :- call_residue_vars(X in 1..3, Vs), Vs = [X].
 `;
         assertIncludes(run(clpzResidue, { goal: 'check' }).stdout, 'check.', 'call_residue_vars/2 includes CLP(Z) attributed variables');
 
+        const deterministicProgram = Program.parse(':- use_module(library(atts)).');
+        const deterministicSolver = new Solver(deterministicProgram);
+        const deterministicGoal = parseGoalText('call_residue_vars(true, Xs)');
+        const deterministicSolutions = deterministicSolver.solve([deterministicGoal], new Env(), 0);
+        const deterministicAnswer = deterministicSolutions.next();
+        assertEqual(deterministicAnswer.done, false, 'call_residue_vars/2 deterministic answer');
+        assertEqual(deterministicSolver.hasPendingAlternatives(), false,
+          'call_residue_vars/2 deterministic success has no leftover choicepoint');
+        deterministicSolutions.return();
+
         const residualFile = path.join(tmp, `atts-residual-${++tmpCounter}.pl`);
         fs.writeFileSync(residualFile, `:- use_module(library(atts)).
+:- use_module(library(freeze), [freeze/2]).
 :- attribute required/1.
 attach(X,V) :- put_atts(X, required(V)).
 verify_attributes(Var, Other, Goals) :-
@@ -189,9 +211,13 @@ verify_attributes(Var, Other, Goals) :-
 same(X,X).
 attribute_goals(X) --> { get_atts(X, required(V)) }, [required(X,V)].
 `);
-        const repl = runCli([], { input: `[${sourceAtom(residualFile)}].\nattach(X,a).\nhalt.\n` });
+        const repl = runCli([], {
+          input: `[${sourceAtom(residualFile)}].\nattach(X,a).\nfreeze(Y,a),dif(Y,c).\nhalt.\n`,
+        });
         assertEqual(repl.status, 0, 'attribute residual REPL status');
         assertIncludes(repl.stdout, 'required(X, a).', 'attribute_goals//1 residual projection');
+        assertIncludes(repl.stdout, 'dif(Y, c), freeze:freeze(Y, a).',
+          'freeze/2 and dif/2 residuals share the query variable (issue #73)');
 
         const scryerShape = Program.parse(`:- module(scryer_shape, [op(700, xfx, #=), probe/0]).
 :- op(700, xfx, #=).