eyeprolog 1.5.66 → 1.5.67

package/package.json

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

package/src/lib/si.pl

@@ -70,12 +70,7 @@ si__condition((A;B)) :- si__condition(A), si__condition(B).
 %  f(a) vs f(Y) and X vs 1 are genuinely undecided.
 compare_si(Order, A, B) :-
     si__require_order(Order),
-    (  A == B
-    -> Order = (=)
-    ;  si__order_decided(A, B)
-    -> compare(Order, A, B)
-    ;  throw(error(instantiation_error, [predicate-compare_si/3]))
-    ).
+    si__compare(Order, [A-B]).
 
 si__require_order(Order) :- var(Order), !.
 si__require_order(Order) :-
@@ -86,25 +81,38 @@ si__require_order(Order) :-
     ; throw(error(type_error(atom, Order), [predicate-compare_si/3]))
     ).
 
-%  Both arguments are known to be non-identical here.
-si__order_decided(A, B) :- ( var(A) ; var(B) ), !, fail.
-si__order_decided(A, B) :-
+% Keep pending argument pairs in a work list. Recursing inside an if-then-else
+% condition retains a child Solver per list cell; testing whole-tail identity
+% at each step also repeatedly scans the same suffix (issue #105).
+si__compare(=, []).
+si__compare(Order, [A-B|Pairs]) :-
+    si__compare_pair(A, B, Comparison, Pairs, Next),
+    si__compare_next(Comparison, Order, Next).
+
+si__compare_next(=, Order, Pairs) :- si__compare(Order, Pairs).
+si__compare_next(<, <, _).
+si__compare_next(>, >, _).
+
+si__compare_pair(A, B, =, Pairs, Pairs) :-
+    ( var(A) ; var(B) ), !,
+    ( A == B -> true
+    ; throw(error(instantiation_error, [predicate-compare_si/3])) ).
+si__compare_pair([A|As], [B|Bs], =, Pairs, [A-B,As-Bs|Pairs]) :- !.
+si__compare_pair(A, B, Comparison, Pairs, Next) :-
     compound(A), compound(B), !,
     functor(A, NameA, ArityA),
     functor(B, NameB, ArityB),
-    (  ArityA =\= ArityB -> true
-    ;  NameA \== NameB -> true
+    (  ArityA =\= ArityB -> compare(Comparison, ArityA, ArityB), Next = Pairs
+    ;  NameA \== NameB -> compare(Comparison, NameA, NameB), Next = Pairs
     ;  A =.. [_|ArgsA],
        B =.. [_|ArgsB],
-       si__args_decided(ArgsA, ArgsB)
-    ).
-%  Otherwise both are non-variables and at least one is atomic, so either the
-%  type order or the values themselves settle it and no instantiation can
-%  change the outcome.
-si__order_decided(_, _).
-
-si__args_decided([A|As], [B|Bs]) :-
-    (  A == B
-    -> si__args_decided(As, Bs)
-    ;  si__order_decided(A, B)
+       Comparison = (=),
+       si__prepend_pairs(ArgsA, ArgsB, Next, Pairs)
     ).
+si__compare_pair(A, _, >, Pairs, Pairs) :- compound(A), !.
+si__compare_pair(_, B, <, Pairs, Pairs) :- compound(B), !.
+si__compare_pair(A, B, Comparison, Pairs, Pairs) :- compare(Comparison, A, B).
+
+si__prepend_pairs([], [], Pairs, Pairs).
+si__prepend_pairs([A|As], [B|Bs], [A-B|Pairs], Tail) :-
+    si__prepend_pairs(As, Bs, Pairs, Tail).

package/test/regression/cases-regression.mjs

@@ -28,6 +28,44 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'timed compare_si/3 backtracks over growing prefixes without exhausting the host stack (issue #105)',
+      run: () => {
+        // Bound the reported generator so the regression exhausts every
+        // answer, including sizes beyond the original 256-cell failure.
+        const result = runCli(['-'], { input:
+          '%% goal: answer(I,R,S)\n' +
+          'answer(I,R,S) :- length(_,I), (I =< 9 -> true ; !, fail), ' +
+          'N is 2^I, length(P,N), append(P,[1],L1), append(P,[2],L2), ' +
+          'time(compare(R,L1,L2)), time(compare_si(S,L1,L2)).\n',
+          timeout: 20000,
+        });
+        assertEqual(result.status, 0, `exit status; error=${result.error}; stderr=${result.stderr}`);
+        for (let i = 0; i <= 9; i++) {
+          assertIncludes(result.stdout, `answer(${i}, <, <).`, 'comparison result');
+        }
+        assertNotIncludes(result.stderr + result.stdout, 'Maximum call stack', 'host stack');
+      },
+    },
+    {
+      name: 'compare_si/3 work list preserves argument priority and instantiation errors',
+      run: () => {
+        const goals = [
+          'compare_si(=,f(X,g(Y)),f(X,g(Y))),var(X),var(Y)',
+          'compare_si(<,f(g(X),a),f(g(X),b)),var(X)',
+          'compare_si(>,f(g(b),a),f(g(a),z))',
+          'compare_si(<,[a|X],[b|Y]),var(X),var(Y)',
+          'compare_si(>,f(X),a),var(X)',
+          'compare_si(<,a,f(X)),var(X)',
+          '\\+ compare_si(>,f(g(X),a),f(g(X),b))',
+          'catch((compare_si(_,f(g(X),a),f(g(Y),b)),fail),error(instantiation_error,[predicate-compare_si/3]),true),var(X),var(Y)',
+        ];
+        for (const goal of goals) {
+          const result = runEyeProlog(`answer(ok) :- ${goal}.`, { goals: ['answer(X)'] });
+          assertIncludes(result.stdout, 'answer(ok)', goal);
+        }
+      },
+    },
     {
       name: 'compare_si/3 validates Order before term instantiation (issue #100)',
       run: () => {