eyeprolog 1.5.67 → 1.5.69

package/package.json

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

package/src/program.js

@@ -320,7 +320,7 @@ export class Program {
         // Numeric closure modes are a widely implemented compatibility
         // extension. Keep their existing hidden lexical qualification while
         // reserving explicit Module:Goal wrapping for ISO Part 2 ':' modes.
-        modes.push({ index, kind: 'closure' });
+        modes.push({ index, kind: 'closure', extraArguments: Number(spec.name) });
       }
     }
     const definitions = this.moduleMetaPredicates.get(module) ?? new Map();
@@ -1179,6 +1179,12 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     return out;
   }
   if (goal?.type !== COMPOUND) return out;
+  if (goal.name === ':' && goal.arity === 2 && goal.args[0]?.type === ATOM) {
+    const start = out.length;
+    collectAutoloadGoalDependencies(goal.args[1], out);
+    for (let i = start; i < out.length; i++) out[i].module ??= goal.args[0].name;
+    return out;
+  }
   if (goal.name === ',' && goal.arity === 2) {
     collectAutoloadGoalDependencies(goal.args[0], out);
     collectAutoloadGoalDependencies(goal.args[1], out);
@@ -1198,7 +1204,7 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     return out;
   }
 
-  out.push({ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module });
+  out.push({ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module, goal });
 
   if (goal.name === 'forall' && goal.arity === 2) {
     collectAutoloadGoalDependencies(goal.args[0], out);
@@ -1219,12 +1225,50 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     collectAutoloadGoalDependencies(goal.args[2], out);
   } else if ((goal.name === 'call_cleanup' || goal.name === 'setup_call_cleanup') && (goal.arity === 2 || goal.arity === 3)) {
     for (const arg of goal.args) collectAutoloadGoalDependencies(arg, out);
-  } else if ((goal.name === 'call' || goal.name === 'time') && goal.arity === 1) {
-    collectAutoloadGoalDependencies(goal.args[0], out);
+  } else if (goal.name === 'call' && goal.arity >= 1) {
+    collectAutoloadClosureDependencies(goal.args[0], goal.arity - 1, out, goal.module);
   }
   return out;
 }
 
+function collectAutoloadClosureDependencies(closure, extraArguments, out, module) {
+  if (closure?.type === COMPOUND && closure.name === ':' && closure.arity === 2 && closure.args[0]?.type === ATOM) {
+    collectAutoloadClosureDependencies(closure.args[1], extraArguments, out, closure.args[0].name);
+    return;
+  }
+  if (closure?.type !== ATOM && closure?.type !== COMPOUND) return;
+  const start = out.length;
+  if (extraArguments === 0) {
+    collectAutoloadGoalDependencies(closure, out);
+  } else {
+    const arity = closure.arity + extraArguments;
+    // Extra closure arguments are unknown here. Record the final indicator
+    // without allocating placeholder terms or treating data arguments as goals.
+    out.push({ key: `${closure.name}/${arity}`, name: closure.name, arity, module: closure.module, goal: closure });
+  }
+  for (let i = start; i < out.length; i++) out[i].module ??= module;
+}
+
+function expandAutoloadMetaDependencies(program, dependencies, module = 'user') {
+  const seen = new WeakMap();
+  for (let i = 0; i < dependencies.length; i++) {
+    const dependency = dependencies[i];
+    if (dependency.goal == null) continue;
+    const caller = dependency.module ?? module;
+    const visitKey = `${caller}\u0000${dependency.key}`;
+    const visits = seen.get(dependency.goal) ?? new Set();
+    if (visits.has(visitKey)) continue;
+    visits.add(visitKey);
+    seen.set(dependency.goal, visits);
+    const group = program.findGroup(dependency.name, dependency.arity, caller);
+    for (const mode of group?.metaArgumentModes ?? []) {
+      if (mode.kind !== 'closure' || !Number.isSafeInteger(mode.extraArguments) || mode.extraArguments < 0) continue;
+      collectAutoloadClosureDependencies(dependency.goal?.args[mode.index], mode.extraArguments, dependencies, caller);
+    }
+  }
+  return dependencies;
+}
+
 function groupAutoloadDependencies(group) {
   const dependencies = [];
   for (const clause of group.clauses) {
@@ -1288,7 +1332,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
   const requests = new Map();
   for (const group of program.groups.values()) {
     if (bundledLibraryModule(program, group.module)) continue;
-    for (const dependency of groupAutoloadDependencies(group)) {
+    for (const dependency of expandAutoloadMetaDependencies(program, groupAutoloadDependencies(group), group.module)) {
       const targetModule = dependency.module ?? group.module;
       if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
       const library = autoloadLibraryFor(dependency);
@@ -1304,7 +1348,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
     }
   }
   for (const goal of program.initializations) {
-    for (const dependency of collectAutoloadGoalDependencies(goal)) {
+    for (const dependency of expandAutoloadMetaDependencies(program, collectAutoloadGoalDependencies(goal))) {
       const targetModule = dependency.module ?? 'user';
       if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
       const library = autoloadLibraryFor(dependency);
@@ -1319,7 +1363,7 @@ function libraryAutoloadRequests(program, extraGoals = []) {
       });
     }
   }
-  for (const dependency of extraGoalDependencies(extraGoals)) {
+  for (const dependency of expandAutoloadMetaDependencies(program, extraGoalDependencies(extraGoals))) {
     const targetModule = dependency.module ?? 'user';
     if (procedureResolvedBeforeAutoload(program, dependency, targetModule)) continue;
     const library = autoloadLibraryFor(dependency);

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, atom, compareTerms, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -838,6 +838,16 @@ export class Solver {
           continue;
         }
 
+        const comparisonIterator = bundledCompareSiIterator(this, group, goal, env);
+        if (comparisonIterator != null) {
+          const firstResult = comparisonIterator.next();
+          if (firstResult.done) break;
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         const lengthIterator = bundledLengthIterator(this, group, goal, env);
         if (lengthIterator != null) {
           const firstResult = lengthIterator.next();
@@ -1778,6 +1788,60 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
   }
 }
 
+// Like the bundled length/member specializations, this keeps the portable
+// Prolog definition available to other registries and user definitions. A
+// direct walk avoids allocating fresh clause variables and doing occurs checks
+// over the remaining list suffix on each comparison step (issue #105).
+function bundledCompareSiIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true || group.bundledLibrary !== true ||
+      group.module !== 'si' || group.name !== 'compare_si' || group.arity !== 3 ||
+      group.tabled || group.clauses.length !== 1) return null;
+  return bundledCompareSiSolutions(solver, goal, env);
+}
+
+const compareSiErrorContext = {};
+function* bundledCompareSiSolutions(solver, goal, env) {
+  try {
+    const order = deref(goal.args[0], env);
+    if (order.type !== VAR) {
+      if (order.type !== ATOM) throw new PrologError('type_error(atom)', order);
+      if (!['<', '=', '>'].includes(order.name)) throw new PrologError('domain_error(order)', order);
+    }
+    const pending = [goal.args[1], goal.args[2]];
+    let comparison = 0;
+    while (pending.length !== 0) {
+      const right = deref(pending.pop(), env);
+      const left = deref(pending.pop(), env);
+      if (left === right) continue;
+      if (left.type === VAR || right.type === VAR) {
+        if (left.type === VAR && right.type === VAR && left.name === right.name) continue;
+        throw new PrologError('instantiation_error');
+      }
+      if (left.type === COMPOUND && right.type === COMPOUND) {
+        if (left.arity !== right.arity) {
+          comparison = left.arity < right.arity ? -1 : 1;
+        } else if (left.name !== right.name) {
+          comparison = compareTerms(atom(left.name), atom(right.name));
+        } else {
+          // Push right-to-left so the first differing argument decides the
+          // result. Later variables must not cause premature errors.
+          for (let i = left.arity - 1; i >= 0; i--) pending.push(left.args[i], right.args[i]);
+          continue;
+        }
+      } else {
+        // At least one operand is atomic: type/value order is already fixed.
+        comparison = compareTerms(left, right);
+      }
+      if (comparison !== 0) break;
+    }
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(goal.args[0], atom(comparison < 0 ? '<' : comparison > 0 ? '>' : '='), next)) yield next;
+  } catch (error) {
+    throw attachBuiltinErrorContext(error, compareSiErrorContext, goal);
+  }
+}
+
 function bundledBetweenIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       group.module !== 'between' || group.name !== 'between' || group.arity !== 3 ||

package/src/term.js

@@ -1586,29 +1586,34 @@ const TYPE_ORDER = { [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]:
 const EMPTY_ENV = new Env();
 
 function compareTermsWithRanks(left, right, variableRanks) {
-  left = deref(left, EMPTY_ENV);
-  right = deref(right, EMPTY_ENV);
-  const lr = TYPE_ORDER[left.type] ?? 0;
-  const rr = TYPE_ORDER[right.type] ?? 0;
-  if (lr !== rr) return lr < rr ? -1 : 1;
-  if (left.type === NUMBER) {
-    const leftInteger = isDecimalInteger(left.name);
-    const rightInteger = isDecimalInteger(right.name);
-    if (leftInteger !== rightInteger) return leftInteger ? 1 : -1;
-    return compareNumberText(left.name, right.name);
-  }
-  if (left.type === VAR) {
-    if (left.name === right.name) return 0;
-    const leftOrder = variableRank(left.name, variableRanks);
-    const rightOrder = variableRank(right.name, variableRanks);
-    return leftOrder < rightOrder ? -1 : 1;
-  }
-  if (left.type === ATOM || left.type === STRING) return compareCharacterText(left.name, right.name);
-  if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
-  if (left.name !== right.name) return compareCharacterText(left.name, right.name);
-  for (let i = 0; i < left.arity; i++) {
-    const cmp = compareTermsWithRanks(left.args[i], right.args[i], variableRanks);
-    if (cmp) return cmp;
+  // Standard compare/3 is used alongside compare_si/3 in issue #105. Walk
+  // argument pairs explicitly so long lists do not exhaust the host stack.
+  const pending = [left, right];
+  while (pending.length !== 0) {
+    right = deref(pending.pop(), EMPTY_ENV);
+    left = deref(pending.pop(), EMPTY_ENV);
+    const lr = TYPE_ORDER[left.type] ?? 0;
+    const rr = TYPE_ORDER[right.type] ?? 0;
+    if (lr !== rr) return lr < rr ? -1 : 1;
+    if (left.type === NUMBER) {
+      const leftInteger = isDecimalInteger(left.name);
+      const rightInteger = isDecimalInteger(right.name);
+      if (leftInteger !== rightInteger) return leftInteger ? 1 : -1;
+      const cmp = compareNumberText(left.name, right.name);
+      if (cmp) return cmp;
+    } else if (left.type === VAR) {
+      if (left.name === right.name) continue;
+      const leftOrder = variableRank(left.name, variableRanks);
+      const rightOrder = variableRank(right.name, variableRanks);
+      return leftOrder < rightOrder ? -1 : 1;
+    } else if (left.type === ATOM || left.type === STRING) {
+      const cmp = compareCharacterText(left.name, right.name);
+      if (cmp) return cmp;
+    } else {
+      if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
+      if (left.name !== right.name) return compareCharacterText(left.name, right.name);
+      for (let i = left.arity - 1; i >= 0; i--) pending.push(left.args[i], right.args[i]);
+    }
   }
   return 0;
 }

package/test/regression/cases-regression.mjs

@@ -28,6 +28,108 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'autoload follows declared meta-predicates and closure arities (issue #105)',
+      run: () => {
+        const wrappers = ':- meta_predicate(mytime(0)).\nmytime(G) :- time(G).\n' +
+          ':- meta_predicate(apply_one(1,?)).\napply_one(G,X) :- call(G,X).\n';
+        for (const goal of ['mytime(mytime(compare_si(<,a,b)))',
+          'apply_one(compare_si(<,a),b)', 'call(compare_si(<),a,b)', 'time(compare_si(<,a,b))']) {
+          const result = runEyeProlog(wrappers, { goals: [goal] });
+          assertIncludes(result.stdout, goal.startsWith('apply_one') ? 'apply_one' : goal.split('(')[0], goal);
+        }
+        const initialized = runEyeProlog(wrappers + ':- initialization((mytime(compare_si(<,a,b)),write(ok))).', { goals: [] });
+        assertIncludes(initialized.stdout, 'ok', 'initialization meta-goal');
+        // A predicate with the same name as a library wrapper can take data.
+        const data = Program.parse('time(_). answer :- time(compare_si(O,a,b)).');
+        assertEqual(data.autoloadedPredicates.some(({ indicator }) => indicator === 'compare_si/3'), false, 'data argument is not a goal');
+      },
+    },
+    {
+      name: 'imported user meta-wrappers autoload caller goals on the first REPL invocation',
+      run: () => {
+        const file = path.join(temp.dir, 'mytime.pl');
+        fs.writeFileSync(file, ':- module(timing_wrapper,[mytime/1]).\n:- meta_predicate(mytime(0)).\nmytime(G) :- time(G).\n');
+        const source = `:- use_module(${sourceAtom(file)}).\nanswer(ok) :- mytime(compare_si(<,a,b)).\n`;
+        assertIncludes(runEyeProlog(source, { goals: ['answer(X)'] }).stdout, 'answer(ok)', 'imported wrapper');
+        const repl = runCli([], { input: `use_module(${sourceAtom(file)}).\nmytime(compare_si(O,a,b)).\n.\nhalt.\n` });
+        assertEqual(repl.status, 0, repl.stderr);
+        assertIncludes(repl.stdout, 'O = (<)', 'first meta-call');
+        assertNotIncludes(repl.stdout + repl.stderr, 'existence_error', 'meta autoload');
+      },
+    },
+    {
+      name: 'bundled compare_si/3 matches the portable definition and respects user definitions',
+      run: () => {
+        const terms = ['X', 'Y', '1', '1.0', '-2', 'a', 'b', '[]', '[X,a]', '[X|Y]',
+          'f(X)', 'f(Y)', 'g(X)', 'f(X,a)', 'f(X,b)', 'f(g(X),a)'];
+        const clauses = [];
+        for (const left of terms) for (const right of terms) {
+          clauses.push(`answer(${clauses.length},R) :- catch((compare_si(O,${left},${right})->R=O;R=failed),error(E,C),R=error(E,C)).`);
+        }
+        const source = clauses.join('\n');
+        const optimized = runEyeProlog(source, { goals: ['answer(I,R)'] });
+        const portable = runEyeProlog(source, { goals: ['answer(I,R)'], registry: createDefaultRegistry() });
+        assertEqual(optimized.stdout, portable.stdout, 'all scalar, variable, compound and list comparisons');
+        const custom = runEyeProlog('compare_si(custom,_,_).', { goals: ['compare_si(O,a,b)'] });
+        assertIncludes(custom.stdout, 'compare_si(custom, a, b)', 'user definition');
+      },
+    },
+    {
+      name: 'compare/3 and compare_si/3 compare large lists and deep terms with a bounded host stack',
+      run: () => {
+        // A separate process bounds regressions in both memory and time. Build
+        // the operands directly so this measures comparison, not append/3.
+        const script = `
+          import {Program,Solver,Env,getEyePrologRegistry,variable,atom,compound,listFromItems,termToString} from './src/index.js';
+          const program = Program.parse(':- use_module(library(si)).');
+          const solver = new Solver(program,{registry:getEyePrologRegistry()});
+          function check(a,b,expected) {
+            for(const name of ['compare','compare_si']) {
+              const order=variable('Order');
+              const answers=[...solver.solve([compound(name,[order,a,b])],new Env(),0)];
+              if (answers.length!==1 || termToString(order,answers[0])!==expected) throw new Error(name+': wrong order');
+            }
+          }
+          for (const n of [16384,65536]) {
+            const prefix=Array.from({length:n},(_,i)=>variable('X'+i));
+            const a=listFromItems([...prefix,atom('a')]);
+            const b=listFromItems([...prefix,atom('b')]);
+            check(a,b,'<'); check(b,a,'>');
+            check(a,listFromItems([...prefix,atom('a')]),'=');
+          }
+          let a=atom('a'), b=atom('b');
+          for(let i=0;i<16384;i++) {a=compound('f',[a]);b=compound('f',[b]);}
+          check(a,b,'<');
+          console.log('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--max-old-space-size=128', '--stack-size=256', '--input-type=module', '--eval', script], {
+          cwd: packageRoot, encoding: 'utf8', timeout: 15000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `large comparison: ${result.stderr}`);
+        assertIncludes(result.stdout, 'ok', 'large comparison completes');
+      },
+    },
+    {
+      name: 'REPL prints the complete 8192-cell timed comparison answer (issue #105)',
+      run: () => {
+        // Keep the large variable-list answer that overflowed REPL printing,
+        // but prepend the differing elements to avoid expensive append/3 setup.
+        // The adjacent cases cover long shared-prefix comparison and append/3
+        // backtracking separately.
+        const result = runCli([], { input:
+          'length(_,I),I=13,N is 2^I,length(P,N),L1=[1|P],L2=[2|P],' +
+          'time(compare(R,L1,L2)),time(compare_si(S,L1,L2)).\n.\nhalt.\n',
+          timeout: 60000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, result.stderr);
+        assertNotIncludes(result.stdout + result.stderr, 'Maximum call stack', 'host stack');
+        assertIncludes(result.stdout, 'I = 13, N = 8192', 'large answer');
+        assertIncludes(result.stdout, 'R = (<), S = (<)', 'both comparison results');
+      },
+    },
     {
       name: 'timed compare_si/3 backtracks over growing prefixes without exhausting the host stack (issue #105)',
       run: () => {