eyeprolog 1.3.8 → 1.3.9

package/README.md

@@ -208,7 +208,9 @@ Trealla/Scryer organization for predicates such as `member/2`, `memberchk/2`,
 `append/2-3`, `nth0/3-4`, `nth1/3-4`, `length/2`, `maplist/2-8`, and
 `foldl/4-6`. Its `length/2` remains relational: with both arguments variable,
 `length(Xs, N)` enumerates lists of increasing length together with `N = 0, 1,
-2, ...`.
+2, ...`. Open-ended generation uses the normal memory guard with recovery
+headroom, so an exhausted finite heap is reported as a catchable
+`resource_error(memory)` instead of degenerating into quadratic list checks.
 
 `library(iso_ext)` is also accepted as a common interop module name.
 EyeProlog exports `call_nth/2` there, so Scryer-style source can explicitly use

package/package.json

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

package/src/solver.js

@@ -17,6 +17,12 @@ import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndex
 
 let freshCounter = 0;
 const DEFAULT_INNER_TABLE_SCOPE_LIMIT = 1024;
+// Conservative live-storage estimate for one generated length/2 list cell
+// (cons object, argument vector, fresh variable, and its generated name).
+const GENERATED_LENGTH_CELL_RESERVE_BYTES = 256;
+const MAX_GENERATED_LENGTH_RESERVE_STEPS = BigInt(
+  Math.floor(Number.MAX_SAFE_INTEGER / GENERATED_LENGTH_CELL_RESERVE_BYTES),
+);
 
 function qualifyTerm(term, module) {
   if (!term || (term.type !== COMPOUND && term.type !== 'atom')) return term;
@@ -1239,13 +1245,17 @@ function* generatedLengthSolutions(solver, list, length, env) {
   let suffix = emptyList();
   for (let extra = 0n; ; extra++) {
     const next = env.clone();
-    solver.stats.unify_calls++;
-    if (unify(cursor, suffix, next)) {
-      const answer = bindGeneratedLength(solver, length, count + extra, next);
-      if (answer != null) yield answer;
-    }
+    // cursor is a dereferenced plain variable and suffix is made only from
+    // freshly generated variables, so this binding cannot create a cycle.
+    // Binding directly avoids an O(extra) occurs-check over the complete
+    // growing suffix for every answer; without this, unbounded length/2
+    // generation becomes quadratic and can spend hours before reaching the
+    // normal memory resource guard (issue #49).
+    next.bind(cursor.name, suffix);
+    const answer = bindGeneratedLength(solver, length, count + extra, next);
+    if (answer != null) yield answer;
     suffix = cons(variable(`__length${id}_${extra}`), suffix);
-    lengthAllocationCheckpoint(solver, ++steps);
+    generatedLengthAllocationCheckpoint(solver, extra + 1n);
   }
 }
 
@@ -1263,6 +1273,19 @@ function lengthAllocationCheckpoint(solver, steps) {
   if ((steps & 255n) === 0n) solver.checkMemoryLimit(true);
 }
 
+function generatedLengthAllocationCheckpoint(solver, steps) {
+  if ((steps & 255n) !== 0n) return;
+  // The open-ended generator retains its current list spine between answers.
+  // Reserve room proportional to that live spine so the protected length/2
+  // call raises resource_error(memory) before its caller's outer solver hits
+  // the same heap limit. This makes the error catchable by catch/3.
+  const estimatedSpineBytes = steps > MAX_GENERATED_LENGTH_RESERVE_STEPS
+    ? Number.MAX_SAFE_INTEGER
+    : Number(steps) * GENERATED_LENGTH_CELL_RESERVE_BYTES;
+  solver.checkMemoryReservation(estimatedSpineBytes);
+  solver.checkMemoryLimit(true);
+}
+
 function pushFastPiFrames(stack, goal, rest, env, depth, active) {
   const values = goal.args.map((arg) => deref(arg, env));
   if ([0, 1, 2, 4].some((index) => values[index].type !== 'number')) return false;

package/test/run-regression.mjs

@@ -3627,6 +3627,45 @@ answer(ok) :-
         }
       },
     },
+    {
+      name: 'unbounded length/2 reaches a catchable memory resource error (issue #49)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import { Program, Solver, Env, deref, variable, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(':- use_module(library(lists)).\n')}, { sourceMetadata: false });
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const goal = parseGoalText('catch(length(L,N),error(E,_),true),L=N', {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let answer = null;
+          for (const env of solver.solve([goal], new Env(), 0)) {
+            answer = env;
+            break;
+          }
+          if (answer == null) throw new Error('issue #49 query produced no caught answer');
+          const formal = deref(variable('E'), answer);
+          if (formal?.name !== 'resource_error' || deref(formal.args?.[0], answer)?.name !== 'memory') {
+            throw new Error('unexpected caught error: ' + JSON.stringify(formal));
+          }
+          const left = deref(variable('L'), answer);
+          const right = deref(variable('N'), answer);
+          if (left.type !== 'var' || right.type !== 'var' || left.name !== right.name) {
+            throw new Error('recovery did not leave L=N');
+          }
+          process.stdout.write('caught');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=64',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 5000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `issue #49 bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'caught', 'issue #49 resource error is caught by catch/3');
+      },
+    },
     {
       name: 'discarded fixed-length lists stay compact under a bounded heap',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1900,9 +1900,15 @@ 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.
+with `compactVariableList`. For open-ended `length(List, N)` generation, the
+bundled path binds each fresh generated spine directly instead of re-running an
+occurs-check over the whole growing list. It also reserves recovery headroom
+proportional to the retained spine, so a finite heap limit is raised inside the
+`length/2` search as a catchable `resource_error(memory)` rather than allowing
+an outer solver frame to encounter the limit first. 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