eyeprolog 1.3.80 → 1.3.82

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.80",
+  "version": "1.3.82",
   "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

@@ -111,18 +111,88 @@ export function runRegression(reporter = new TestReporter(), requestedSection =
 function regressionCases() {
   return [
     {
-      name: 'dif/2 keeps a delayed disequality across later unification (issue #68)',
-      run: () => {
-        assertEqual(run('', { goal: 'dif(1,Y),Y=1' }).stats.completed_goal_lists, 0,
-          'binding a constrained variable to the forbidden value fails');
-        assertEqual(run('', { goal: 'dif(1,Y),Y=2' }).stats.completed_goal_lists, 1,
-          'binding a constrained variable to a different value succeeds');
-        assertEqual(run('', { goal: 'dif(X,Y),X=Y' }).stats.completed_goal_lists, 0,
-          'aliasing two constrained variables fails');
-        assertEqual(run('', { goal: 'dif(X-Y,1-2),X=Y,Y=1' }).stats.completed_goal_lists, 1,
-          'a specialization that makes the terms non-unifiable discharges the constraint');
-        assertEqual(run('', { goal: 'dif(X-Y,1-2),X=Y,X=2' }).stats.completed_goal_lists, 1,
-          'a second specialization discharges the same structural constraint');
+      name: 'dif/2 passes the WG17 finite-tree comparison cases (issue #68)',
+      run: () => {
+        // Comparison cases from
+        // https://www.complang.tuwien.ac.at/ulrich/iso-prolog/dif
+        const comparisonCases = [
+          ['1', true, 'dif(1,2)'],
+          ['2', false, 'dif(1,Y),Y=1'],
+          ['3', true, 'dif(1,Y),Y=2'],
+          ['4', false, 'dif(X,-Y),X= -Y'],
+          ['5', false, 'dif(X,Y),X=Y'],
+          ['6', false, 'dif(X,Y),X=Y,X=1'],
+          ['7', false, 'dif(-X,-Y),X=Y'],
+          ['8', false, 'dif(-X,-Y),X=Y,X=1'],
+          ['9', true, 'dif(-X,X)'],
+          ['10', true, 'dif(-X,Y),X=Y'],
+          ['11', true, 'X=Y,dif(X-Y,1-2)'],
+          ['12', true, 'dif(X-Y,1-2),X=Y'],
+          ['13', true, 'X=Y,Y=1,dif(X-Y,1-2)'],
+          ['14', true, 'dif(X-Y,1-2),X=Y,Y=1'],
+          ['15', true, 'dif(X-Y,1-2),X=Y,X=2'],
+          ['16', true, 'dif(A-C,B-D),C-D=z-z,A-B=1-2'],
+          ['17', true, 'A-B=1-2,C-D=z-z,dif(A-C,B-D)'],
+          ['18', true, 'dif(A,[C|B]),A=[[]|_],A=[B]'],
+          ['19', true, 'dif([E],[/]),E=1'],
+          ['20', true, 'dif([a],B),B=[_|_],B=[b]'],
+          ['21', true, 'dif([],A),A=[_]'],
+          ['22', true, 'A=[_],dif([],A)'],
+          // Cases 23-26 are implementation-defined in the comparison. These
+          // assertions record EyeProlog's term-copying and collector
+          // choices so changes remain deliberate.
+          ['23', true, 'dif(X,a),copy_term(X,a)'],
+          ['24', true, 'findall(X,dif(X,a),[a])'],
+          ['25', true, 'setof(t,dif(X,a),_),X=a'],
+          ['26', true, 'setof(t,(dif(X,a);dif(X,b)),_),X=a'],
+        ];
+        for (const [id, succeeds, query] of comparisonCases) {
+          const result = run(`check :- ${query}.`, { goal: 'check' });
+          assertEqual(result.stdout, succeeds ? 'check.\n' : '', `WG17 dif/2 case ${id}`);
+        }
+
+        // EyeProlog is a finite-tree processor. The comparison's rational-tree
+        // probes must terminate as failures instead of constructing cycles.
+        const rationalTreeCases = [
+          ['t1', '\\+ \\+ -X=X'],
+          ['t2', '-X=X,-Y=Y,X\\=Y'],
+          ['t3', '-X=X,dif(X,1)'],
+          ['t4', '-X=X,-Y=Y,dif(X,Y)'],
+          ['t5', 'dif(X,Y),-X=X,-Y=Y'],
+          ['t6', 'A=[[]|A],dif(A,B),B=[[]|A]'],
+          ['t7', 'dif(-X,X),-Y=Y,X=Y'],
+          ['t8', '-X=X,dif(X,Y),X=Y'],
+        ];
+        for (const [id, query] of rationalTreeCases) {
+          assertEqual(run(`check :- ${query}.`, { goal: 'check' }).stdout, '',
+            `WG17 dif/2 ${id} terminates under finite-tree unification`);
+        }
+
+        for (const [id, query, succeeds] of [
+          ['o1', '-X=X', false],
+          ['o2', 'dif(-X,X)', true],
+          ['o3', 'dif(-X,Y),X=Y', true],
+        ]) {
+          assertEqual(run(`check :- ${query}.`, { goal: 'check' }).stdout,
+            succeeds ? 'check.\n' : '', `WG17 dif/2 occurs-check case ${id}`);
+        }
+
+        const residuals = runCli([], {
+          input:
+            'dif(A-C,B-D),C-D=z-z.\n' +
+            'dif(A,[C|B]),A=[[]|_],A=[B].\n' +
+            'dif(X-Y,1-2),X=Y.\n' +
+            'halt.\n',
+        });
+        assertEqual(residuals.status, 0, 'dif/2 residual display status');
+        assertEqual(residuals.stdout,
+          '?-    C = z, D = z, dif(A - z, B - z).\n' +
+          '?-    A = [[]], B = [], dif([[]], [C]).\n' +
+          '?-    X = Y.\n' +
+          '?- ',
+          'dif/2 residual constraints are retained and discharged');
+        assertEqual(residuals.stderr, '', 'dif/2 residual display stderr');
+
         assertEqual(run('p(a).', { goal: 'dif(X,a),p(X)' }).stats.completed_goal_lists, 0,
           'scalar-fact fast matching still validates annotated variables');
         assertEqual(run('p(b).', { goal: 'dif(X,a),p(X)' }).stats.completed_goal_lists, 1,
@@ -1827,7 +1897,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 +1922,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)'),