eyeprolog 1.2.15 → 1.2.17

package/package.json

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

package/src/repl.js

@@ -9,7 +9,7 @@ const ANSWER_HELP = `
 SPACE, "n" or ";": next solution, if any
 RETURN or ".": stop enumeration
 "a": enumerate all solutions
-"f": enumerate the next 5 solutions
+"f": enumerate through the next group of 5 solutions
 "h": display this help message
 "w": write terms without depth limit
 "p": print terms with depth limit
@@ -486,11 +486,13 @@ async function solveQuery(engine, state, goal, reader, output) {
   }
 
   let automatic = 0;
+  let answersShown = 0;
   let firstAnswer = true;
   while (!current.result.done) {
     const next = pullSolution(solver, solutions, reader);
     output.write(current.output);
     output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
+    answersShown++;
     firstAnswer = false;
     if (!next.error && next.result.done) {
       output.write('.\n');
@@ -516,7 +518,12 @@ async function solveQuery(engine, state, goal, reader, output) {
           break;
         }
         if (control === 'f') {
-          automatic = 4;
+          // `f` groups leaf answers in blocks of five, rather than merely
+          // adding five more answers after whatever the user has already
+          // inspected. Stop for control again at the next 5-answer boundary.
+          const remainder = answersShown % 5;
+          const answersToBoundary = remainder === 0 ? 5 : 5 - remainder;
+          automatic = answersToBoundary - 1;
           break;
         }
         if (control === 'w' || control === 'p') {

package/src/solver.js

@@ -490,10 +490,11 @@ function normalizeHostResourceError(error) {
   const message = String(error?.message ?? '');
   // V8 reports exhausted Map/Set capacity as a host RangeError.  ISO 7.12.2 h
   // requires processor resource exhaustion to surface as resource_error/1,
-  // with the resource atom implementation dependent.  EyeProlog uses the
-  // finite_memory spelling already accepted by its ISO conformance corpus.
+  // with the resource atom implementation dependent.  A finite host capacity
+  // ceiling is reported as `memory`; reserve `finite_memory` for the separate
+  // convention where no finite amount of memory can complete the computation.
   if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
-    return new PrologError('resource_error(finite_memory)');
+    return new PrologError('resource_error(memory)');
   }
   return error;
 }

package/test/run-regression.mjs

@@ -752,6 +752,48 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL f stops at five-answer boundaries instead of adding five answers',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'use_module(library(prologue), [between/3]).\n' +
+            'between(0,11,I).\nf\n\n' +
+            'between(0,11,J).\n;\n;\nf\n\n' +
+            'between(0,11,K).\nf\nf\n\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    true.\n' +
+          '?-    I = 0\n' +
+          ';  I = 1\n' +
+          ';  I = 2\n' +
+          ';  I = 3\n' +
+          ';  I = 4\n' +
+          ';  ... .\n' +
+          '?-    J = 0\n' +
+          ';  J = 1\n' +
+          ';  J = 2\n' +
+          ';  J = 3\n' +
+          ';  J = 4\n' +
+          ';  ... .\n' +
+          '?-    K = 0\n' +
+          ';  K = 1\n' +
+          ';  K = 2\n' +
+          ';  K = 3\n' +
+          ';  K = 4\n' +
+          ';  K = 5\n' +
+          ';  K = 6\n' +
+          ';  K = 7\n' +
+          ';  K = 8\n' +
+          ';  K = 9\n' +
+          ';  ... .\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL parenthesizes operator-valued answer substitutions',
       run: () => {
@@ -2221,22 +2263,27 @@ open(X) :- candidate(X), \\+ closed(X).
       },
     },
     {
-      name: 'host Map capacity errors become ISO resource errors',
+      name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {
-        const registry = new BuiltinRegistry();
-        registry.add('exhaust_map', 0, function* () {
-          throw new RangeError('Map maximum size exceeded');
-        });
-        const solver = new Solver(Program.parse(''), { registry });
-        const goal = parseGoalText('exhaust_map');
-        let caught = null;
-        try {
-          [...solver.solve([goal], new Env(), 0)];
-        } catch (error) {
-          caught = error;
+        for (const [predicate, message] of [
+          ['exhaust_map', 'Map maximum size exceeded'],
+          ['exhaust_set', 'Set maximum size exceeded'],
+        ]) {
+          const registry = new BuiltinRegistry();
+          registry.add(predicate, 0, function* () {
+            throw new RangeError(message);
+          });
+          const solver = new Solver(Program.parse(''), { registry });
+          const goal = parseGoalText(predicate);
+          let caught = null;
+          try {
+            [...solver.solve([goal], new Env(), 0)];
+          } catch (error) {
+            caught = error;
+          }
+          assertEqual(caught?.name, 'PrologError', `${predicate} normalized error type`);
+          assertEqual(caught?.formal, 'resource_error(memory)', `${predicate} normalized resource error`);
         }
-        assertEqual(caught?.name, 'PrologError', 'normalized error type');
-        assertEqual(caught?.formal, 'resource_error(finite_memory)', 'normalized resource error');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1823,8 +1823,12 @@ sorted-list operation. No process-global variable registry or creation ordinal
 is retained or exposed through later comparisons.
 
 Host capacity failures that V8 reports as `Map maximum size exceeded` or `Set`
-`maximum size exceeded` are normalized at the solver boundary to the ISO error
-`resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
+`maximum size exceeded` are normalized at the solver boundary to
+`resource_error(memory)` instead of leaking a JavaScript `RangeError`. ISO
+13211-1 leaves the resource atom implementation dependent. EyeProlog uses
+`memory` for a finite host allocation/capacity ceiling and reserves the
+`finite_memory` spelling for the distinct convention where no finite amount of
+memory could complete the computation.
 
 ### Implementation boundary
 
@@ -6260,8 +6264,10 @@ may span lines and end with a full stop, as in Scryer Prolog:
 
 When another answer exists in an interactive terminal, press `;`, Space, or
 `n` to ask for it immediately; no Return is needed. Return or `.` stops
-enumeration, `a` enumerates all remaining answers, `f` enumerates the next
-five, and `h` displays the answer-control help. While a query is actively
+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. While a query is actively
 computing, EyeProlog releases readline's terminal signal handling: `Ctrl-C`
 therefore terminates the current EyeProlog process immediately, and on POSIX
 terminals `Ctrl-Z` suspends it in the usual shell-managed way. This remains a