eyeprolog 1.2.34 → 1.2.35

package/package.json

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

package/src/iso.js

@@ -2029,35 +2029,39 @@ function* negationBuiltin({ solver, goal, env }) {
   for (const _ of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) return;
   yield env;
 }
+function* solveControlBranch(solver, goal, env) {
+  for (const answer of solver.solve([callable(goal, env)], env, 0)) {
+    // A branch answer is internal to its enclosing control construct. The
+    // surrounding solve will count the completed control goal after the
+    // builtin yields it. Leaving both counts in place makes a bounded search
+    // such as once/1 or negation stop before it can observe the branch answer.
+    if (solver.solutionsSeen > 0) solver.solutionsSeen--;
+    yield answer;
+  }
+}
 function* disjunctionBuiltin({ solver, goal, env }) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
     for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(left.args[0], env)], env.clone(), 0)) {
-      yield* solver.solve([callable(left.args[1], conditionEnv)], conditionEnv, 0);
+      yield* solveControlBranch(solver, left.args[1], conditionEnv);
       return;
     }
-    yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+    yield* solveControlBranch(solver, goal.args[1], env.clone());
     return;
   }
   const marker = solver.active[solver.active.length - 1] ?? null;
   const markerCutEpoch = marker?.cutEpoch ?? 0;
   const solverCutEpoch = solver.cutEpoch;
-  yield* solver.solve([callable(goal.args[0], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[0], env.clone());
   const cutThisScope = marker == null
     ? solver.cutEpoch !== solverCutEpoch
     : (marker.cutEpoch ?? 0) !== markerCutEpoch;
   if (cutThisScope) return;
-  yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[1], env.clone());
 }
 function* ifThenBuiltin({ solver, goal, env }) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
-    for (const consequentEnv of solver.solve([callable(goal.args[1], conditionEnv)], conditionEnv, 0)) {
-      // The consequent is an internal part of the current solution, not a
-      // completed top-level solution. Keep a surrounding bounded search (for
-      // example nested ISO once-as-if-then) from consuming its limit early.
-      if (solver.solutionsSeen > 0) solver.solutionsSeen--;
-      yield consequentEnv;
-    }
+    yield* solveControlBranch(solver, goal.args[1], conditionEnv);
     return;
   }
 }

package/test/run-regression.mjs

@@ -477,6 +477,32 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'negation observes disjunction through direct and call/1 execution',
+      run: () => {
+        const reported = publicApi.runQuads(String.raw`?- \+ (true ; true).
+   false.
+
+?- call(\+ (true ; true)).
+   false.
+`);
+        assertEqual(reported.total, 2, 'reported query count');
+        assertEqual(reported.passed, 2, 'reported queries pass');
+
+        const program = Program.parse('');
+        const answerCount = (text) => {
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          return [...solver.solve([parseGoalText(text)], new Env(), 0)].length;
+        };
+
+        assertEqual(answerCount(String.raw`\+ (true ; true)`), 0, 'direct successful disjunction is negated');
+        assertEqual(answerCount(String.raw`call(\+ (true ; true))`), 0, 'called negation fails');
+        assertEqual(answerCount(String.raw`\+ (true ; fail)`), 0, 'successful left branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; true)`), 0, 'successful right branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; fail)`), 1, 'failed disjunction is negated');
+        assertEqual(answerCount('once((true ; true))'), 1, 'once keeps the first disjunction answer');
+      },
+    },
     {
       name: 'runQuads passes the complete vendored ISO phrase quad corpus',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1844,7 +1844,10 @@ normalized at the solver boundary instead of leaking a JavaScript `RangeError`.
 ISO 13211-1 leaves the resource atom implementation dependent. EyeProlog uses
 `memory` for a finite host allocation/capacity ceiling and reserves the
 `finite_memory` spelling for the distinct convention where no finite amount of
-memory could complete the computation.
+memory could complete the computation. After a recoverable memory error, the
+solver keeps a bounded recovery window while the failed search unwinds so the
+host can collect released query terms. The same solver can then run later
+queries; this recovery does not resume the query that exhausted its limit.
 
 The iterative solver keeps active-call frames only where they are semantically
 needed for cut scope or recursive variant guards. Bundled-library helpers whose
@@ -1853,9 +1856,15 @@ guard therefore do not copy a growing active-call sequence at every step.
 Under the normal EyeProlog registry, the bundled Prologue `length/2` also has a
 scoped iterative execution path: named lists are counted or constructed without
 recursive interpreter frames, and an anonymous list is not materialized because
-its binding cannot be observed. The ordinary clauses remain the authoritative
-module definition and are used unchanged by the ISO-only registry and whenever
-delays or finite-domain constraints require their normal wake-up points.
+its binding cannot be observed. A newly constructed fixed-length suffix starts
+as a lazy compact skeleton and expands one ordinary `./2` cell at a time when
+unification, another list predicate, or answer readback inspects it. This is a
+storage optimization, not a distinct Prolog term or list semantics. Embedders
+that inspect the JavaScript term model can recognize this representation with
+`CompactListTerm`, `isCompactList`, and `compactListLength`, or construct one
+with `compactVariableList`. The ordinary clauses remain the authoritative module
+definition and are used unchanged by the ISO-only registry and whenever delays
+or finite-domain constraints require their normal wake-up points.
 
 ### Implementation boundary