eyeprolog 1.3.34 → 1.3.35

package/package.json

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

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

@@ -679,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);
   }

package/test/run-regression.mjs

@@ -1675,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: () => {
@@ -1707,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; });
 
@@ -1728,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