eyeprolog 1.3.8 → 1.3.10

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.10",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/program.js

@@ -314,15 +314,10 @@ export class Program {
     const wfsNegativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
+      let compactDependencies = null;
       for (const clause of group.clauses) {
         if (isCompactBinaryClause(clause)) {
-          if (clause.bodyName != null) {
-            const dep = this.findGroup(clause.bodyName, 2, group.module);
-            if (dep) {
-              deps[groupIndex].add(indexByGroup.get(dep));
-              cutDeps[groupIndex].add(indexByGroup.get(dep));
-            }
-          }
+          if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
           continue;
         }
         for (const goal of clause.body) {
@@ -349,6 +344,13 @@ export class Program {
           }
         }
       }
+      for (const name of compactDependencies ?? []) {
+        const dep = this.findGroup(name, 2, group.module);
+        if (!dep) continue;
+        const dependencyIndex = indexByGroup.get(dep);
+        deps[groupIndex].add(dependencyIndex);
+        cutDeps[groupIndex].add(dependencyIndex);
+      }
     }
     const finiteDatalogCache = new Map();
     const rangeRestrictedDatalogCache = new Map();
@@ -1301,12 +1303,10 @@ function datalogDependencyClauseCount(program, group, seen = new Set()) {
   if (seen.has(group)) return 0;
   seen.add(group);
   let count = group.clauses.length;
+  let compactDependencies = null;
   for (const clause of group.clauses) {
     if (isCompactBinaryClause(clause)) {
-      if (clause.bodyName != null) {
-        const target = program.findGroup(clause.bodyName, 2, group.module);
-        if (target) count += datalogDependencyClauseCount(program, target, seen);
-      }
+      if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
       continue;
     }
     for (const goal of clause.body) {
@@ -1315,6 +1315,10 @@ function datalogDependencyClauseCount(program, group, seen = new Set()) {
       if (target) count += datalogDependencyClauseCount(program, target, seen);
     }
   }
+  for (const name of compactDependencies ?? []) {
+    const target = program.findGroup(name, 2, group.module);
+    if (target) count += datalogDependencyClauseCount(program, target, seen);
+  }
   return count;
 }
 
@@ -1324,12 +1328,10 @@ function isFiniteDatalogGroup(program, group, cache = new Map(), visiting = new
   if (visiting.has(group)) return true;
   visiting.add(group);
   let finite = true;
+  let compactDependencies = null;
   for (const clause of group.clauses) {
     if (isCompactBinaryClause(clause)) {
-      if (clause.bodyName != null) {
-        const target = program.findGroup(clause.bodyName, 2, group.module);
-        if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
-      }
+      if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
       continue;
     }
     if (clause.head.type === COMPOUND && !clause.head.args.every(isFiniteDatalogArgument)) { finite = false; break; }
@@ -1345,6 +1347,12 @@ function isFiniteDatalogGroup(program, group, cache = new Map(), visiting = new
     }
     if (!finite) break;
   }
+  if (finite) {
+    for (const name of compactDependencies ?? []) {
+      const target = program.findGroup(name, 2, group.module);
+      if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+    }
+  }
   visiting.delete(group);
   cache.set(group, finite);
   return finite;
@@ -1358,7 +1366,35 @@ function isRangeRestrictedFiniteDatalogGroup(program, group, cache = new Map(),
   visiting.add(group);
   let finite = true;
 
+  let compactDependencyResults = null;
   for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      const head0Variable = clause.head0Type === VAR;
+      const head1Variable = clause.head1Type === VAR;
+      if (clause.bodyName == null) {
+        if (head0Variable || head1Variable) { finite = false; break; }
+        continue;
+      }
+      const head0RangeRestricted = !head0Variable ||
+        (clause.body0Type === VAR && clause.body0Name === clause.head0Name) ||
+        (clause.body1Type === VAR && clause.body1Name === clause.head0Name);
+      const head1RangeRestricted = !head1Variable ||
+        (clause.body0Type === VAR && clause.body0Name === clause.head1Name) ||
+        (clause.body1Type === VAR && clause.body1Name === clause.head1Name);
+      if (!head0RangeRestricted || !head1RangeRestricted) {
+        finite = false;
+        break;
+      }
+      let targetFinite = compactDependencyResults?.get(clause.bodyName);
+      if (targetFinite == null) {
+        const target = program.findGroup(clause.bodyName, 2, group.module);
+        targetFinite = target != null && isRangeRestrictedFiniteDatalogGroup(program, target, cache, visiting);
+        (compactDependencyResults ??= new Map()).set(clause.bodyName, targetFinite);
+      }
+      if (!targetFinite) { finite = false; break; }
+      continue;
+    }
+
     const head = clause.head;
     if ((head.type !== COMPOUND && head.type !== ATOM) ||
         (head.type === COMPOUND && !head.args.every(isFiniteDatalogArgument))) {

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: () => {
@@ -4445,6 +4484,23 @@ function whiteBoxCases() {
         assertEqual(ground.stats.datalog_evaluations, 0, 'ground query keeps the ordinary indexed chain path');
       },
     },
+    {
+      name: 'compact finite Datalog planning preserves lazy clause terms',
+      run: () => {
+        const facts = Array.from({ length: 130 }, (_, i) => `compact_edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${facts}\ncompact_edge(X,Y) :- compact_edge(X,Y).\n`;
+        const program = Program.parseSources([{ text: source, filename: 'compact-datalog.pl' }], {
+          sourceMetadata: false,
+        });
+        const group = program.findGroup('compact_edge', 2);
+        assertEqual(group.datalogLeastModel, true, 'compact recursive Datalog remains eligible');
+        assertEqual(
+          group.clauses.filter((clause) => clause._head != null || clause._body != null).length,
+          0,
+          'planning keeps compact clause terms lazy',
+        );
+      },
+    },
     {
       name: 'findall length counting preserves multiplicity and observable bags',
       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