eyeprolog 1.3.96 → 1.3.97

package/package.json

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

@@ -2078,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,8 +6286,11 @@ 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: