eyeprolog 1.2.42 → 1.2.44

package/package.json

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

package/src/iso.js

@@ -1198,6 +1198,15 @@ function scopeReadTerm(term) {
 
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
+  // A standalone number needs no general term parser or operator tables.
+  // Reuse the same bounded numeric scanner as number_chars/2 so stream reads
+  // and number conversion agree on every accepted numeric token. The stream
+  // scanner has already established that the final full stop is a candidate
+  // terminator; trim only ISO layout immediately before that terminator.
+  const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
+  const numericTerm = parseIsoNumber(numericText);
+  if (numericTerm != null) return numericTerm;
+
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
   const clauses = parseClauses(converted, {
     sourceMetadata: false,

package/src/standard-library.js

@@ -2,9 +2,10 @@
 // The sources are registered here so library(Name) works in Node and browsers;
 // unlike the former autoloader, no clauses are added unless use_module/1 or
 // use_module/2 requests their module.
-import { createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
+import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { clpzBuiltins } from './clpz.js';
-import { fs, isNode } from './platform.js';
+import { fs, isNode, memoryStatistics } from './platform.js';
+import { ATOM, VAR, atom, deref, numberTerm, unify } from './term.js';
 
 const moduleFiles = Object.freeze({
   aggregate: 'aggregate.pl',
@@ -73,8 +74,44 @@ export const eyePrologLibraryIndicators = Object.freeze([
   ...eyePrologNativeLibraryIndicators,
 ]);
 
+function runtimeStatistics(solver) {
+  return { ...solver.stats, ...memoryStatistics() };
+}
+
+function* statisticsBuiltin({ solver, env }) {
+  const stream = solver.io.resolve(solver.io.currentOutput);
+  if (stream?.type !== 'text') throw new PrologError('permission_error(output, binary_stream)');
+  solver.io.writeUnit(stream, 'eyeprolog stats:\n');
+  for (const [key, value] of Object.entries(runtimeStatistics(solver))) {
+    solver.io.writeUnit(stream, `  ${key}: ${value}\n`);
+  }
+  yield env;
+}
+
+function* statisticsValueBuiltin({ solver, goal, env }) {
+  const snapshot = runtimeStatistics(solver);
+  const key = deref(goal.args[0], env);
+  const entries = key.type === VAR
+    ? Object.entries(snapshot)
+    : key.type === ATOM && Object.hasOwn(snapshot, key.name)
+      ? [[key.name, snapshot[key.name]]]
+      : null;
+
+  if (entries == null) {
+    if (key.type !== ATOM) throw new PrologError('type_error(atom)', key);
+    return;
+  }
+
+  for (const [name, value] of entries) {
+    const next = env.clone();
+    if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], numberTerm(value), next)) yield next;
+  }
+}
+
 export function createEyePrologRegistry() {
   const registry = createDefaultRegistry();
+  registry.add('statistics', 0, statisticsBuiltin, { deterministic: true });
+  registry.add('statistics', 2, statisticsValueBuiltin);
   eyePrologLibraryBuiltins.register(registry);
   clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;

package/test/run-regression.mjs

@@ -692,6 +692,108 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'read/2 and number_chars/2 agree on bounded numeric syntax (issue #29)',
+      run: () => {
+        const registry = createDefaultRegistry();
+        const numberChars = registry.get('number_chars', 2).handler;
+        const read = registry.get('read', 2).handler;
+        const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
+        const stream = solver.io.resolve(0);
+        const streamTerm = compound('$stream', [numberTerm('0')]);
+        const alphabet = ['0', '1', '2', '7', '8', '9', 'a', 'f', 'x', 'e', 'E', '+', '-', '.', "'", '\\', ' '];
+        let checked = 0;
+        let accepted = 0;
+
+        const visit = (prefix, remaining) => {
+          if (remaining === 0) {
+            checked++;
+            const converted = variable('Converted');
+            const conversionGoal = compound('number_chars', [
+              converted,
+              listFromItems(Array.from(prefix, atom)),
+            ]);
+            let conversion;
+            try {
+              conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
+            } catch (_) {
+              return;
+            }
+            if (conversion.done) return;
+            accepted++;
+            const expected = copyResolved(converted, conversion.value);
+
+            stream.content = `${prefix}. `;
+            stream.position = 0;
+            stream.pastEnd = false;
+            const readValue = variable('ReadValue');
+            const readGoal = compound('read', [streamTerm, readValue]);
+            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
+            if (answer.done) throw new Error(`read/2 rejected number_chars/2 spelling ${JSON.stringify(prefix)}`);
+            const actual = copyResolved(readValue, answer.value);
+            assertEqual(actual.type, 'number', `read/2 type for ${JSON.stringify(prefix)}`);
+            assertEqual(actual.name, expected.name, `read/2 value for ${JSON.stringify(prefix)}`);
+            return;
+          }
+          for (const character of alphabet) visit(prefix + character, remaining - 1);
+        };
+
+        for (let length = 1; length <= 4; length++) visit('', length);
+        assertEqual(checked, 88740, 'bounded numeric spellings checked');
+        if (accepted < 1000) throw new Error(`unexpectedly small accepted numeric corpus: ${accepted}`);
+      },
+    },
+    {
+      name: 'number_chars/2 to read/2 cross-check stays bounded under a small heap (issue #29)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import {
+            Program, Solver, Env, atom, compound, variable, listFromItems,
+            numberTerm, copyResolved, createDefaultRegistry,
+          } from ${JSON.stringify(engineUrl)};
+          const registry = createDefaultRegistry();
+          const numberChars = registry.get('number_chars', 2).handler;
+          const read = registry.get('read', 2).handler;
+          const solver = new Solver(Program.parse(''), { registry, ioOptions: { input: '' } });
+          const stream = solver.io.resolve(0);
+          const streamTerm = compound('$stream', [numberTerm('0')]);
+          for (let i = 0; i < 250000; i++) {
+            const text = String(i);
+            const converted = variable('Converted');
+            const conversionGoal = compound('number_chars', [
+              converted,
+              listFromItems(Array.from(text, atom)),
+            ]);
+            const conversion = numberChars({ goal: conversionGoal, env: new Env() }).next();
+            if (conversion.done) throw new Error('number_chars/2 failed at ' + i);
+            const expected = copyResolved(converted, conversion.value);
+
+            stream.content = text + '. ';
+            stream.position = 0;
+            stream.pastEnd = false;
+            const readValue = variable('ReadValue');
+            const readGoal = compound('read', [streamTerm, readValue]);
+            const answer = read({ solver, goal: readGoal, env: new Env() }).next();
+            if (answer.done) throw new Error('read/2 failed at ' + i);
+            const actual = copyResolved(readValue, answer.value);
+            if (actual.type !== 'number' || actual.name !== expected.name) {
+              throw new Error('number mismatch at ' + i + ': ' + actual.name + ' != ' + expected.name);
+            }
+          }
+          process.stdout.write('250000');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=32',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, '250000', 'number_chars/read cross-check count');
+      },
+    },
     {
       name: 'number syntax and number_chars normalize floating-point negative zero',
       run: () => {
@@ -1975,6 +2077,36 @@ c4 ?- call((!;1)).
         assertIncludes(result.stderr, '  solve_goals_calls:', 'stderr');
       },
     },
+    {
+      name: 'statistics/0 prints snapshots during execution',
+      run: () => {
+        const input = '%% goal: live\nlive :- statistics, statistics.\n';
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual((result.stdout.match(/eyeprolog stats:/g) ?? []).length, 2, 'in-run snapshot count');
+        assertIncludes(result.stdout, '  memory_guard_used_bytes:', 'stdout');
+        assertIncludes(result.stdout, 'live.\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'statistics/2 exposes current counters and memory values',
+      run: () => {
+        const input = '%% goal: live(Used)\nlive(Used) :- statistics(memory_guard_used_bytes, Used).\n';
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(/^live\(\d+\)\.\n$/.test(result.stdout), true, 'numeric memory statistic');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'statistics predicates are excluded from strict ISO mode',
+      run: () => {
+        const result = runCli(['--iso-strict', '-'], { input: '%% goal: statistics\n' });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'existence_error(procedure)', 'stderr');
+      },
+    },
     {
       name: '--warnings prints unstratified negation diagnostics without failing',
       run: () => {
@@ -3205,9 +3337,13 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 153, 'EyeProlog registry contains ISO definitions and private library adapters');
+        assertEqual(library.defs.size, 155, 'EyeProlog registry contains ISO definitions, observability extensions, and private library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
+        assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
+        assertEqual(registry.get('statistics', 2), null, 'statistics/2 is absent from the ISO registry');
+        assertEqual(Boolean(library.get('statistics', 0)), true, 'statistics/0 is an EyeProlog observability extension');
+        assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 59, 'portable Prolog library count');
         assertEqual(eyePrologNativeLibraryIndicators.length, 40, 'native host library count');

package/the-art-of-eyeprolog.md

@@ -4635,9 +4635,20 @@ may indicate a generator that should be constrained. Many table hits may show
 effective reuse; many distinct table entries may reveal an argument that
 prevents calls from sharing. On the Node CLI it also reports current heap use,
 non-young/old-generation use, the amount currently compared with the memory
-guard, resident-set size, and the soft and hard memory ceilings in bytes. These memory figures are printed even when execution ends by
-raising a Prolog error, which makes `--stats` useful when reproducing bounded
-memory failures such as long-running conversion stress tests.
+guard, resident-set size, and the soft and hard memory ceilings in bytes. These
+memory figures are printed even when execution ends by raising a Prolog error.
+
+`--stats` is an end-of-run summary. For a deliberately non-terminating or very
+long computation, call the EyeProlog extension `statistics/0` at the points
+where a live snapshot is useful. For example, a long-running loop can include
+`statistics` as one of its goals, as in `loop :- work, statistics, loop.`
+
+`statistics/0` writes the current solver counters and memory figures
+immediately to the current output stream. `statistics/2` makes an individual
+value available to the program, for example
+`statistics(memory_guard_used_bytes, Used)`. With an unbound first argument it
+enumerates the available statistic keys and values. These predicates are
+EyeProlog observability extensions and are not available under `--iso-strict`.
 
 Compare statistics only between runs with the same query, data, and observable
 answer contract. A faster program that silently loses answers is not an
@@ -6410,7 +6421,7 @@ make the observed question explicit.
 | `-p`, `--proof` | Print `why/2` explanations |
 | `-q`, `--quads` | Run embedded quad tests and fail if any do not hold |
 | `--iso-strict` | Restrict parsing and execution to ISO/IEC 13211-1:1995 + Corrigenda 1–3; reject EyeProlog language extensions and disable automatic tabling |
-| `-s`, `--stats` | Print solver counters to stderr |
+| `-s`, `--stats` | Print final solver and memory statistics to stderr after execution |
 | `-v`, `--version` | Print the package version |
 | `-w`, `--warnings` | Print non-fatal portability warnings |
 | `-g`, `--goal Goal` | Solve a callable goal; may be repeated; overrides `%% goal:` comments |