eyeprolog 1.3.33 → 1.3.35

package/package.json

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

package/src/iso.js

@@ -1939,7 +1939,13 @@ function validateControlCallable(term, culprit, env) {
     if (current.type !== COMPOUND || ![',', ';', '->'].includes(current.name) || current.arity !== 2) continue;
     for (let index = current.arity - 1; index >= 0; index--) {
       const argument = deref(current.args[index], env);
-      if (argument.type === VAR) throw new PrologError('instantiation_error');
+      // A variable nested in a control construct is not an error at call/1
+      // entry: an earlier goal may instantiate it before execution reaches
+      // that position. If it is still unbound when selected, the solver then
+      // raises instantiation_error at that point, after any preceding effects.
+      // Non-variable non-callables are different: ISO call/1 validates those
+      // eagerly and reports the whole control term as the culprit.
+      if (argument.type === VAR) continue;
       if (argument.type !== ATOM && argument.type !== COMPOUND) {
         throw new PrologError('type_error(callable)', culprit);
       }

package/src/quads.js

@@ -247,7 +247,10 @@ function executeQuery(program, query, input, maxSolutions, options) {
     error,
     tailOutput,
     inputPosition,
-    loops: solver.depthLimitExceeded || solver.inferenceLimitExceeded,
+    // Accept direct structural evidence from EyeProlog's recursion guard as
+    // well as bounded-search evidence. A detected active-variant cycle is
+    // stronger evidence than merely reaching a timeout/inference ceiling.
+    loops: solver.recursionCycleDetected || solver.depthLimitExceeded || solver.inferenceLimitExceeded,
   };
 }
 

package/src/repl.js

@@ -18,6 +18,8 @@ RETURN or ".": stop enumeration
 "p": print terms with depth limit
 `;
 
+const SCRIPTED_NEXT_QUERY = Symbol('scripted-next-query');
+
 export async function runRepl(engine, options = {}) {
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
@@ -102,6 +104,7 @@ class LineReader {
     this.output = output;
     this.terminal = Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === 'function');
     this.history = [];
+    this.pendingLines = [];
     this.currentPrompt = '?- ';
     this.open();
   }
@@ -119,16 +122,30 @@ class LineReader {
     this.lines = this.readline[Symbol.asyncIterator]();
   }
 
+  async nextLine() {
+    if (this.pendingLines.length > 0) return { done: false, value: this.pendingLines.shift() };
+    return this.lines.next();
+  }
+
   async read(prompt) {
     this.currentPrompt = prompt;
     this.readline.setPrompt(prompt);
     this.output.write(prompt);
-    const result = await this.lines.next();
+    const result = await this.nextLine();
     return result.done ? null : result.value;
   }
 
   async readControl(prompt) {
-    if (!this.terminal) return this.read(prompt);
+    if (!this.terminal) {
+      const result = await this.nextLine();
+      if (result.done) return null;
+      if (!isScriptedAnswerControl(result.value)) {
+        this.pendingLines.unshift(result.value);
+        return SCRIPTED_NEXT_QUERY;
+      }
+      this.output.write(prompt);
+      return result.value;
+    }
     this.output.write(prompt);
     this.history = [...this.readline.history];
     this.currentPrompt = '?- ';
@@ -250,6 +267,12 @@ class LineReader {
   }
 }
 
+function isScriptedAnswerControl(line) {
+  if (line == null || line === '' || line === '\r' || line === '\n' || line === ' ') return true;
+  const control = line.trim();
+  return control.startsWith('.') || [';', 'n', 'a', 'f', 'w', 'p', 'h'].includes(control);
+}
+
 function runWithTerminalSignals(reader, operation) {
   const suspended = reader.suspendForComputation();
   try {
@@ -541,7 +564,6 @@ async function readSource(designation) {
 async function solveQuery(engine, state, goal, reader, output) {
   const variables = queryVariables(goal);
   const solver = state.solver;
-  const demandDriven = containsTimedGoal(goal);
   solver.solutionsSeen = 0;
   const solutions = solver.solve([goal], new engine.Env(), 0);
   let current = pullSolution(solver, solutions, reader);
@@ -560,12 +582,11 @@ async function solveQuery(engine, state, goal, reader, output) {
   let firstAnswer = true;
   let formattingAfterAdvance = false;
   while (!current.result.done) {
-    // Ordinary queries keep the existing eager look-ahead so deterministic
-    // answers can end with a full stop without showing an unnecessary answer
-    // prompt. `time/1` is different: running a future solution changes what is
-    // being measured and can retain a very large current substitution. Timed
-    // queries therefore advance only after the user asks for another answer.
-    const next = demandDriven ? null : pullSolution(solver, solutions, reader);
+    // Enumeration is demand-driven: never execute search for a future answer
+    // merely to decide how to punctuate the current one. That search may have
+    // side effects, and it belongs only to an explicit request for another
+    // answer. A scripted non-TTY session may start its next query directly;
+    // LineReader treats that as an implicit stop without consuming the query.
     if (formattingAfterAdvance) output.write(' ');
     formattingAfterAdvance = false;
     output.write(current.output);
@@ -574,7 +595,11 @@ async function solveQuery(engine, state, goal, reader, output) {
     answersShown++;
     firstAnswer = false;
 
-    if (demandDriven ? !solver.hasPendingAlternatives() : (!next.error && next.result.done)) {
+    if (!solver.hasPendingAlternatives()) {
+      // The solver is suspended at the yielded answer even though no work is
+      // left. Close the generator to run its cleanup/finally blocks without
+      // advancing search or executing future side effects.
+      if (typeof solutions.return === 'function') solutions.return();
       output.write(`${continuesGraphicToken(answer, answer.length) ? ' ' : ''}.\n`);
       return null;
     }
@@ -586,6 +611,11 @@ async function solveQuery(engine, state, goal, reader, output) {
     } else {
       while (true) {
         const controlLine = await reader.readControl('\n;');
+        if (controlLine === SCRIPTED_NEXT_QUERY) {
+          if (typeof solutions.return === 'function') solutions.return();
+          output.write(`${continuesGraphicToken(answer, answer.length) ? ' ' : ''}.\n`);
+          return null;
+        }
         if (controlLine == null || controlLine === '' || controlLine === '\r' || controlLine === '\n' ||
             controlLine.trimStart().startsWith('.')) {
           if (typeof solutions.return === 'function') solutions.return();
@@ -618,52 +648,29 @@ async function solveQuery(engine, state, goal, reader, output) {
       formattingAfterAdvance = true;
     }
 
-    if (demandDriven) {
-      // The displayed timed answer is no longer needed. Drop it before
-      // resuming search so a large list substitution does not remain live only
-      // because the top level is looking for its successor.
-      current = null;
-      const requested = pullSolution(solver, solutions, reader);
-      if (requested.error) {
-        if (formattingAfterAdvance) output.write(' ');
-        formattingAfterAdvance = false;
-        output.write(requested.output);
-        if (requested.error?.name === 'HaltSignal') return { halted: true, code: requested.error.code };
-        throw requested.error;
-      }
-      if (requested.result.done) {
-        if (formattingAfterAdvance) output.write(' ');
-        formattingAfterAdvance = false;
-        output.write(`${requested.output}false.\n`);
-        return null;
-      }
-      current = requested;
-      continue;
+    // Drop the displayed substitution before resuming search. The next search
+    // step, including any side effects, happens only after the user asked for
+    // another answer (or selected automatic enumeration).
+    current = null;
+    const requested = pullSolution(solver, solutions, reader);
+    if (requested.error) {
+      if (formattingAfterAdvance) output.write(' ');
+      formattingAfterAdvance = false;
+      output.write(requested.output);
+      if (requested.error?.name === 'HaltSignal') return { halted: true, code: requested.error.code };
+      throw requested.error;
     }
-
-    if (next.error) {
+    if (requested.result.done) {
       if (formattingAfterAdvance) output.write(' ');
       formattingAfterAdvance = false;
-      output.write(next.output);
-      if (next.error?.name === 'HaltSignal') return { halted: true, code: next.error.code };
-      throw next.error;
+      output.write(`${requested.output}false.\n`);
+      return null;
     }
-    current = next;
+    current = requested;
   }
   return null;
 }
 
-function containsTimedGoal(goal) {
-  const stack = [goal];
-  while (stack.length !== 0) {
-    const term = stack.pop();
-    if (term?.type !== 'compound') continue;
-    if (term.name === 'time' && term.arity === 1) return true;
-    for (let index = term.args.length - 1; index >= 0; index--) stack.push(term.args[index]);
-  }
-  return false;
-}
-
 function pullSolution(solver, solutions, reader) {
   const stream = solver.io.resolve('user_output');
   const originalWrite = stream?.write;

package/src/solver.js

@@ -63,6 +63,10 @@ export class Solver {
     // limit accounting. time/1 snapshots this counter around the measured goal.
     this.inferenceObservation = options.inferenceObservation ?? { value: 0 };
     this.inferenceLimitExceeded = false;
+    // Set when the normal-profile recursion guard detects re-entry of an
+    // already active variant on the current search path. Quad `loops` checks
+    // use this structural evidence in addition to bounded resource probes.
+    this.recursionCycleDetected = false;
     this.maxMemoryBytes = options.maxMemoryBytes ?? softHeapLimit();
     this.memoryRecovery = options.memoryRecovery ?? {
       active: false,
@@ -261,6 +265,7 @@ export class Solver {
     if (!child || child === this || !child.stats) return;
     this.depthLimitExceeded ||= child.depthLimitExceeded;
     this.inferenceLimitExceeded ||= child.inferenceLimitExceeded;
+    this.recursionCycleDetected ||= child.recursionCycleDetected;
     for (const [key, value] of Object.entries(child.stats)) {
       if (key === 'max_depth' || key === 'max_goal_count') {
         this.stats[key] = Math.max(this.stats[key] ?? 0, value ?? 0);
@@ -674,7 +679,7 @@ export class Solver {
 
   hasPendingAlternatives() {
     // When solve() is suspended at an answer, active solve stacks contain only
-    // unexplored work. The timed REPL path uses this without speculatively
+    // unexplored work. The demand-driven REPL uses this without speculatively
     // pulling the next answer.
     return this.solveStacks.some((stack) => stack.length !== 0);
   }
@@ -845,7 +850,10 @@ export class Solver {
   }
 
   *solveUserGoalUncached(group, goal, rest, env, depth) {
-    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) return;
+    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) {
+      this.recursionCycleDetected = true;
+      return;
+    }
     // Program indexes provide candidate clauses, but every candidate is still
     // freshened and unified below. The index is a performance hint, not a
     // semantic shortcut.
@@ -1047,7 +1055,10 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
 }
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
-  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) return;
+  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) {
+    solver.recursionCycleDetected = true;
+    return;
+  }
   if (group.fastPi && pushFastPiFrames(stack, goal, rest, env, depth, active)) return;
   if (tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, depth, active)) return;
   if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
@@ -1981,7 +1992,10 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     }
 
     const goal = runGoals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2035,7 +2049,10 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     }
 
     const goal = goals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2205,7 +2222,11 @@ function tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const seenSet = seen[secondType];
-    if (!seenSet || seenSet.has(secondName)) return true;
+    if (!seenSet) return true;
+    if (seenSet.has(secondName)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (cache[secondType].has(secondName)) {
       rememberCompactChainSuccess(cache, seen);
       stack.push({ kind: 'goals', goals: rest, env, depth: depth + 1, active });
@@ -2326,8 +2347,14 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const key = groundChainKey(currentGoal);
-    if (seen.has(key)) return true;
-    if (activeVariantIn(currentGoal, currentEnv, active)) return true;
+    if (seen.has(key)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
+    if (activeVariantIn(currentGoal, currentEnv, active)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (solver.groundChainSuccess.has(key)) {
       rememberGroundChainSuccess(solver, seen);
       stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });

package/test/run-regression.mjs

@@ -1317,6 +1317,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads preserves output before a delayed call/1 instantiation error (issue #57)',
+      run: () => {
+        const result = publicApi.runQuads(`16, "7.8.3.4#9"\n?- call((write(3), X)).\n   outputs("3"), instantiation_error.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'runQuads recognizes recursion-guard cycle evidence as loops (issue #58)',
+      run: () => {
+        const result = publicApi.runQuads(`inf :- inf, inf.\n\n23\n?- inf.\n   loops.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: '--quads runs embedded tests and reports failures through exit status',
       run: () => {
@@ -1659,6 +1675,52 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL does not precompute an unrequested future alternative (issue #48)',
+      run: () => {
+        const result = runCli([], {
+          input: '(X = first; (repeat, fail)).\nhalt.\n',
+          timeout: 2000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, '?-    X = first.\n?- ', 'first answer is immediate');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL executes future side effects only after another answer is requested (issue #48)',
+      run: () => {
+        const stopped = runCli([], {
+          input:
+            '(X = first; (assertz(issue48_seen), X = second)).\n' +
+            'current_predicate(issue48_seen/0).\n' +
+            'halt.\n',
+        });
+        assertEqual(stopped.status, 0, 'stopped status');
+        assertEqual(
+          stopped.stdout,
+          '?-    X = first.\n?-    false.\n?- ',
+          'unrequested branch has no side effect',
+        );
+
+        const advanced = runCli([], {
+          input:
+            '(X = first; (assertz(issue48_seen), X = second)).\n' +
+            ';\n' +
+            'current_predicate(issue48_seen/0).\n' +
+            'halt.\n',
+        });
+        assertEqual(advanced.status, 0, 'advanced status');
+        assertEqual(
+          advanced.stdout,
+          '?-    X = first\n;  X = second.\n?-    true.\n?- ',
+          'requested branch performs its side effect',
+        );
+        assertEqual(stopped.stderr, '', 'stopped stderr');
+        assertEqual(advanced.stderr, '', 'advanced stderr');
+      },
+    },
     {
       name: 'REPL bindings use argument syntax for operator atoms',
       run: () => {
@@ -1691,7 +1753,7 @@ c4 ?- call((!;1)).
           child.stdout.on('data', (text) => {
             stdout += text;
             if (stdout.endsWith('?-   ')) sawQueryComputingPrompt = true;
-            if (stdout.endsWith('\\n; ')) sawComputingPrompt = true;
+            if (stdout.includes('\\n; ')) sawComputingPrompt = true;
           });
           child.stderr.on('data', (text) => { stderr += text; });
 
@@ -1712,10 +1774,10 @@ c4 ?- call((!;1)).
           await waitFor(() => sawQueryComputingPrompt, 'query computing prompt');
           await waitFor(() => stdout.endsWith('   false.\\n?- '), 'query result');
           child.stdin.write('(N = 0; N = 1; (call_nth(repeat, 100000), N = 2)).\\n');
-          await waitFor(() => stdout.endsWith('   N = 0\\n;'), 'waiting prompt');
+          await waitFor(() => stdout.endsWith('   N = 0'), 'first answer');
           child.stdin.write(';\\n');
           await waitFor(() => sawComputingPrompt, 'computing prompt');
-          await waitFor(() => stdout.endsWith(';  N = 1\\n;'), 'formatted answer');
+          await waitFor(() => stdout.endsWith(';  N = 1'), 'formatted answer');
           child.stdin.write('\\n');
           await waitFor(() => stdout.endsWith('  ... .\\n?- '), 'stopped enumeration');
           child.stdin.write('halt.\\n');

package/the-art-of-eyeprolog.md

@@ -6645,8 +6645,16 @@ When another answer exists in an interactive terminal, press `;`, Space, or
 enumeration, `a` enumerates all remaining answers, and `f` advances to the
 next five-answer boundary (5, 10, 15, ... displayed leaf answers), regardless
 of how many answers were stepped through individually beforehand. `h` displays
-the answer-control help. Once the top-level reader has accepted a complete
-query, the following line begins with two spaces to mark active execution; a
+the answer-control help. Enumeration is demand-driven: after an answer is
+found, the top level does not pull a successor merely to discover whether the
+current answer is the last one. Search for a later answer, including any side
+effects reached on that path, starts only after an answer-control command asks
+to continue. If an unresolved alternative ultimately has no solution, asking
+for it may therefore finish with `false.`. In scripted non-TTY input, a new
+query line implicitly stops the preceding answer enumeration without consuming
+the new query; explicit `;`, `n`, Space, `a`, or `f` still requests more
+answers. Once the top-level reader has accepted a complete query, the following
+line begins with two spaces to mark active execution; a
 third space appears when its result is ready for formatting. The answer prompt
 is `;` with no trailing space while it waits for input; after an advance
 command, one space marks active search and a second marks an answer ready for
@@ -6831,9 +6839,12 @@ variable in the renamed exception term. `...` and `ad_infinitum` accept further
 indented descriptions after one query are independent checks: each re-runs the
 query, each is counted in the `quads:` summary, and a failing description does
 not suppress later descriptions for that query. `inputs/1` supplies and checks
-consumed characters; `outputs/1` checks emitted characters. `sto` marks
-an answer description that this finite-tree implementation skips. `loops` is
-checked with a deterministic solver-depth budget. The advanced stream
+consumed characters; `outputs/1` checks characters emitted while reaching
+the described answer or error, including output produced before a later
+exception. `sto` marks an answer description that this finite-tree
+implementation skips. `loops` accepts direct active-variant cycle evidence from
+EyeProlog's normal recursion guard, with bounded depth/inference exhaustion as a
+fallback for loops that have no such structural witness. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
 annotation, are not executed by the current runner.