eyeprolog 1.3.95 → 1.3.97

package/examples/book/README.md

@@ -238,12 +238,13 @@ npm run generate
 
 ## Chapter 39: Built-in predicates by programming role
 
-- [01-answer.pl](chapter-39/01-answer.pl) — The EyeProlog library
-- [02-answer-2.pl](chapter-39/02-answer-2.pl)
-- [03-answer-3.pl](chapter-39/03-answer-3.pl)
-- [04-cost.pl](chapter-39/04-cost.pl)
-- [05-message.pl](chapter-39/05-message.pl)
-- [06-task.pl](chapter-39/06-task.pl)
+- [01-program.pl](chapter-39/01-program.pl) — The EyeProlog library
+- [02-answer.pl](chapter-39/02-answer.pl)
+- [03-answer-2.pl](chapter-39/03-answer-2.pl)
+- [04-answer-3.pl](chapter-39/04-answer-3.pl)
+- [05-cost.pl](chapter-39/05-cost.pl)
+- [06-message.pl](chapter-39/06-message.pl)
+- [07-task.pl](chapter-39/07-task.pl)
 
 ## Chapter 40: Running EyeProlog: command line and corpus
 

package/examples/book/chapter-39/01-program.pl

@@ -0,0 +1,4 @@
+% From The Art of EyeProlog, Chapter 39 — The EyeProlog library.
+?- dif(f(X,A),f(Y,B)), ( true ; A = B ).
+   dif(f(X, A), f(Y, B))
+;  A = B, dif(X, Y).

package/examples/book/chapter-39/{01-answer.pl → 02-answer.pl}

@@ -1,4 +1,4 @@
-% From The Art of EyeProlog, Chapter 39 — The EyeProlog library.
+% From The Art of EyeProlog, Chapter 39.
 :- use_module(library(dates)).
 :- use_module(library(between), [between/3]).
 :- use_module(library(random)).

package/package.json

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

package/src/lib/freeze.pl

@@ -10,19 +10,29 @@ verify_attributes(Var, Other, Goals) :-
     get_atts(Var, frozen(FrozenA)), !,
     ( var(Other) ->
         ( get_atts(Other, frozen(FrozenB)) ->
-            put_atts(Other, frozen((FrozenB,FrozenA)))
+            append_frozen(FrozenB, FrozenA, Frozen),
+            put_atts(Other, frozen(Frozen))
         ; put_atts(Other, frozen(FrozenA))
         ),
         Goals = []
-    ; Goals = [FrozenA]
+    ; Goals = FrozenA
     ).
 verify_attributes(_, _, []).
 
 freeze(X, Goal) :-
-    put_atts(Fresh, frozen(Goal)),
+    put_atts(Fresh, frozen([Goal])),
     Fresh = X.
 
 attribute_goals(Var) -->
     { get_atts(Var, frozen(Goals)),
       put_atts(Var, -frozen(_)) },
-    [freeze:freeze(Var, Goals)].
+    frozen_attribute_goals(Goals, Var).
+
+frozen_attribute_goals([], _) --> [].
+frozen_attribute_goals([Goal|Goals], Var) -->
+    [freeze:freeze(Var, Goal)],
+    frozen_attribute_goals(Goals, Var).
+
+append_frozen([], Tail, Tail).
+append_frozen([Goal|Goals], Tail, [Goal|Merged]) :-
+    append_frozen(Goals, Tail, Merged).

package/test/run-regression.mjs

@@ -400,6 +400,20 @@ function regressionCases() {
           'dif/2 residuals are minimal without auxiliary terms');
         assertEqual(residuals.stderr, '', 'dif/2 normalization display stderr');
 
+        const perfection = runCli([], {
+          input:
+            'dif(f(X,A),f(Y,B)), ( true ; A = B ).\n' +
+            ';\n' +
+            'halt.\n',
+        });
+        assertEqual(perfection.status, 0, 'dif/2 branch-local projection status');
+        assertEqual(perfection.stdout,
+          '?-    dif(f(X, A), f(Y, B))\n' +
+          ';  A = B, dif(X, Y).\n' +
+          '?- ',
+          'dif/2 residual projection is re-evaluated after branch-local bindings');
+        assertEqual(perfection.stderr, '', 'dif/2 branch-local projection stderr');
+
         const pendingDifCount = (text) => {
           const solver = new Solver(Program.parse(''), { registry: getEyePrologRegistry() });
           const solutions = solver.solve([parseGoalText(text)], new Env(), 0);
@@ -2064,6 +2078,38 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'Prologue freeze keeps multiple delayed goals in separate cut scopes (issue #84)',
+      run: () => {
+        const result = publicApi.runQuads(`:- use_module(library(prologue)).
+39
+?- freeze(X,(Y=1;Y=2)), freeze(X,!), X = c ; X=end.
+   X = c, Y = 1
+;  X = end, unexpected.
+   X = c, Y = 1
+;  X = c, Y = 2
+;  X = end.
+`);
+        assertEqual(result.total, 2, 'quad total');
+        assertEqual(result.passed, 2, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+        assertEqual(result.stdout, 'quads: 2 run, 2 passed, 0 failed.\n', 'quad report');
+
+        const residuals = runCli([], {
+          input:
+            'use_module(library(freeze)).\n' +
+            'freeze(X,(Y=1;Y=2)), freeze(X,!).\n' +
+            'halt.\n',
+        });
+        assertEqual(residuals.status, 0, 'freeze residual display status');
+        assertEqual(residuals.stdout,
+          '?-    true.\n' +
+          '?-    freeze:freeze(X, (Y=1;Y=2)), freeze:freeze(X, !).\n' +
+          '?- ',
+          'multiple freeze/2 residuals stay separate');
+        assertEqual(residuals.stderr, '', 'freeze residual display stderr');
+      },
+    },
     {
       name: 'runQuads covers the remaining finite Prologue examples and arities',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -6286,14 +6286,25 @@ kept in the logical environment, so bindings and backtracking remain isolated
 between solution branches. When a suspension wakes, its goal is meta-invoked
 with its own cut scope: a `!` inside the delayed goal may commit choices made by
 that invocation, but it cannot prune alternatives that were created before the
-`freeze/2` call. Thus `call(((Y=1;Y=2),freeze(X,!),X=c));Y=3` retains the three
-answers `Y=1`, `Y=2`, and `Y=3`.
+`freeze/2` call. Multiple suspensions on the same variable also remain distinct
+meta-invocations rather than being collapsed into one conjunction, so a cut in
+one frozen goal cannot prune alternatives produced by another frozen goal. Thus
+`call(((Y=1;Y=2),freeze(X,!),X=c));Y=3` retains the three answers `Y=1`, `Y=2`,
+and `Y=3`.
 
 `dif(?Left,?Right)` posts a delayed finite-tree disequality when its arguments
 can still unify. Its residual store is normalized by logical implication:
 symmetric or equivalent constraints share one residual, and a stronger
 constraint removes weaker ones regardless of insertion order. Independent
-disequalities remain separate.
+disequalities remain separate. Residual projection is re-evaluated in each
+solution environment, so a compound disequality is kept intact until later
+bindings make one aligned subterm pair sufficient. For example:
+
+```eyeprolog
+?- dif(f(X,A),f(Y,B)), ( true ; A = B ).
+   dif(f(X, A), f(Y, B))
+;  A = B, dif(X, Y).
+```
 
 <!-- eyeprolog-library-catalog:start -->