eyeprolog 1.3.0 → 1.3.2

package/README.md

@@ -138,14 +138,17 @@ predicates use ISO atoms or character lists. The old catch-all
 EyeProlog keeps a conservative source-level interoperability profile separate
 from the larger EyeProlog library surface. `library(lists)` follows the common
 Trealla/Scryer organization for predicates such as `member/2`, `memberchk/2`,
-`append/2-3`, `nth0/3-4`, `nth1/3-4`, `maplist/2-8`, and `foldl/4-6`.
+`append/2-3`, `nth0/3-4`, `nth1/3-4`, `length/2`, `maplist/2-8`, and
+`foldl/4-6`. Its `length/2` remains relational: with both arguments variable,
+`length(Xs, N)` enumerates lists of increasing length together with `N = 0, 1,
+2, ...`.
 
 Outside `--iso-strict`, an otherwise undefined unqualified call may autoload a
 predicate only when the interop profile has one canonical EyeProlog provider.
-For example, `member/2` autoloads from `library(lists)` and `between/3` can use
-EyeProlog's internal Prologue implementation without requiring portable source
-to name `library(prologue)`. Use `--no-autoload` to disable this convenience.
-Strict ISO mode never autoloads library predicates.
+For example, `member/2` autoloads from `library(lists)`, while `between/3` and
+`call_nth/2` can use EyeProlog's internal Prologue implementation without
+requiring portable source to name `library(prologue)`. Use `--no-autoload` to
+disable this convenience. Strict ISO mode never autoloads library predicates.
 
 Use `-w` / `--warnings` to diagnose dependencies outside the interop profile,
 or `--portable` to make such diagnostics fail the run. This catches both

package/package.json

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

package/src/lib/lists.pl

@@ -133,8 +133,17 @@ nth1(N, List, Elem, Rest) :-
 
 reverse(List, Reversed) :- lists__reverse(List, [], Reversed).
 
-length(List, Length) :- nonvar(List), lists__length_count(List, 0, Length).
-length(List, Length) :- var(List), integer(Length), Length >= 0, lists__length_make(Length, List).
+% Keep the common lists:length/2 relation fully relational.  In particular,
+% length(List, Length) with both arguments variable enumerates lists of
+% increasing length, as required by portable generators such as the issue #28
+% number_chars/2 stress test.
+length(List, Length) :-
+    nonvar(Length), !,
+    lists__integer(Length),
+    lists__not_less_than_zero(Length),
+    lists__length_fixed(Length, List).
+length(List, Length) :-
+    lists__length_generate(List, 0, Length).
 
 foldl(_, [], Acc, Acc).
 foldl(Closure, [A|As], Acc0, Acc) :-
@@ -186,10 +195,25 @@ slice(Start, Count, List, Slice) :-
 lists__reverse([], Acc, Acc).
 lists__reverse([X|Xs], Acc, Out) :- lists__reverse(Xs, [X|Acc], Out).
 
-lists__length_count([], N, N).
-lists__length_count([_|Xs], N0, N) :- N1 is N0 + 1, lists__length_count(Xs, N1, N).
-lists__length_make(0, []).
-lists__length_make(N, [_|Xs]) :- N > 0, N1 is N - 1, lists__length_make(N1, Xs).
+lists__length_fixed(0, []).
+lists__length_fixed(N, [_|Xs]) :-
+    N > 0,
+    N1 is N - 1,
+    lists__length_fixed(N1, Xs).
+
+lists__length_generate([], N, N).
+lists__length_generate([_|Xs], N0, N) :-
+    N1 is N0 + 1,
+    lists__length_generate(Xs, N1, N).
+
+lists__integer(X) :- integer(X), !.
+lists__integer(X) :- var(X), !, 0 is X.
+% arg/3 performs the ISO integer type check before inspecting its term.
+lists__integer(X) :- arg(X, type_check, _).
+
+lists__not_less_than_zero(X) :- X >= 0, !.
+% atom_length/2 reports domain_error(not_less_than_zero) for a negative value.
+lists__not_less_than_zero(X) :- atom_length('', X).
 
 lists__sum_list([], Sum, Sum).
 lists__sum_list([X|Xs], Acc, Sum) :- Next is Acc + X, lists__sum_list(Xs, Next, Sum).

package/src/repl.js

@@ -55,7 +55,10 @@ export async function runRepl(engine, options = {}) {
         }
         const consultFiles = options.isoStrict ? null : consultDesignations(engine, goal);
         if (consultFiles != null) {
-          for (const filename of consultFiles) sources.push(await readSource(filename));
+          for (const filename of consultFiles) {
+            const source = await readSource(filename);
+            replaceConsultedSource(sources, source);
+          }
           state = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write(' true.\n');
@@ -447,10 +450,32 @@ function isHaltGoal(goal) {
 }
 
 function consultDesignations(engine, goal) {
+  // The traditional [file]. top-level shorthand and explicit consult/1 use
+  // the same resolver and modern reconsult semantics.  Accept reconsult/1 as
+  // a compatibility alias as well; contemporary consult/1 already replaces
+  // clauses previously loaded from the same source.
   if (goal.type === 'atom' && goal.name === '[]') return [];
-  if (goal.type !== 'compound' || goal.name !== '.' || goal.arity !== 2) return null;
-  const items = engine.properListItems(goal, new engine.Env());
-  if (items == null) return null;
+  if (goal.type === 'compound' && goal.name === '.' && goal.arity === 2) {
+    return consultListDesignations(engine, goal);
+  }
+  if (goal.type === 'compound' && ['consult', 'reconsult'].includes(goal.name) && goal.arity === 1) {
+    return consultArgumentDesignations(engine, goal.args[0]);
+  }
+  return null;
+}
+
+function consultArgumentDesignations(engine, term) {
+  if (term.type === 'var') throw new engine.PrologError('instantiation_error');
+  if (term.type === 'atom') return term.name === '[]' ? [] : [term.name];
+  if (term.type === 'compound' && term.name === '.' && term.arity === 2) {
+    return consultListDesignations(engine, term);
+  }
+  throw new engine.PrologError('type_error(atom)', term);
+}
+
+function consultListDesignations(engine, list) {
+  const items = engine.properListItems(list, new engine.Env());
+  if (items == null) throw new engine.PrologError('type_error(list)', list);
   return items.map((item) => {
     if (item.type === 'var') throw new engine.PrologError('instantiation_error');
     if (item.type !== 'atom') throw new engine.PrologError('type_error(atom)', item);
@@ -458,18 +483,43 @@ function consultDesignations(engine, goal) {
   });
 }
 
-async function readSource(designation) {
-  let filename = path.resolve(designation);
-  try {
-    await fs.access(filename);
-  } catch (error) {
-    if (path.extname(filename)) throw error;
-    filename += '.pl';
+function replaceConsultedSource(sources, source) {
+  const index = sources.findIndex((existing) =>
+    source.consultPath != null && existing.consultPath === source.consultPath);
+  if (index >= 0) sources[index] = source;
+  else sources.push(source);
+}
+
+function missingSource(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+async function resolvedConsultFilename(designation) {
+  const requested = path.resolve(designation);
+  // Long-standing Prolog consult convention: for an extensionless name, try
+  // the .pl source first and use the unsuffixed path only as a fallback.
+  if (!path.extname(requested)) {
+    const prologFile = `${requested}.pl`;
+    try {
+      await fs.access(prologFile);
+      return await fs.realpath(prologFile);
+    } catch (error) {
+      if (!missingSource(error)) throw error;
+    }
   }
+  await fs.access(requested);
+  return fs.realpath(requested);
+}
+
+async function readSource(designation) {
+  const filename = await resolvedConsultFilename(designation);
   return {
     text: await fs.readFile(filename, 'utf8'),
     filename: path.basename(filename),
     baseDir: path.dirname(filename),
+    // Keep host-only provenance so consulting the same resolved file again
+    // replaces its previous source instead of accumulating stale clauses.
+    consultPath: filename,
   };
 }
 

package/src/standard-library.js

@@ -109,6 +109,10 @@ export const eyePrologInteropAutoload = Object.freeze({
   'foldl/6': 'lists',
   'sum_list/2': 'lists',
   'list_to_set/2': 'lists',
+  // call_nth/2 is available in both Trealla and Scryer (the latter via
+  // library(iso_ext)).  EyeProlog keeps its adapter in library(prologue), so
+  // autoloading hides that implementation-specific location from source.
+  'call_nth/2': 'prologue',
   // Trealla and Scryer expose between/3 without an EyeProlog-style
   // library(prologue) dependency.  EyeProlog keeps its implementation in the
   // Prologue module but autoloads it so portable source need not name that
@@ -150,7 +154,7 @@ function* statisticsValueBuiltin({ solver, goal, env }) {
 
   if (entries == null) {
     if (key.type !== ATOM) throw new PrologError('type_error(atom)', key);
-    return;
+    throw new PrologError('domain_error(statistics_key)', key);
   }
 
   for (const [name, value] of entries) {

package/test/run-regression.mjs

@@ -1712,6 +1712,143 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL consult prefers .pl over an unsuffixed file (issue #47)',
+      run: () => {
+        const stem = path.join(tmp, `repl-consult-order-${++tmpCounter}`);
+        fs.writeFileSync(stem, 'chosen(bare).\n');
+        fs.writeFileSync(`${stem}.pl`, 'chosen(pl).\n');
+        const result = runCli([], {
+          input: `[${sourceAtom(stem)}].\nchosen(X).\nhalt.\n`,
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, 'X = pl.', 'consulted .pl source');
+        assertNotIncludes(result.stdout, 'X = bare', 'unsuffixed source is fallback only');
+        assertEqual(result.stderr, '', 'stderr');
+
+        const explicit = runCli([], {
+          input: `consult(${sourceAtom(stem)}).\nchosen(X).\nhalt.\n`,
+        });
+        assertEqual(explicit.status, 0, 'consult/1 exit status');
+        assertIncludes(explicit.stdout, 'X = pl.', 'consult/1 prefers .pl source');
+        assertNotIncludes(explicit.stdout, 'X = bare', 'consult/1 does not prefer unsuffixed source');
+        assertEqual(explicit.stderr, '', 'consult/1 stderr');
+
+        fs.rmSync(`${stem}.pl`);
+        const fallback = runCli([], {
+          input: `[${sourceAtom(stem)}].\nchosen(X).\nhalt.\n`,
+        });
+        assertEqual(fallback.status, 0, 'fallback exit status');
+        assertIncludes(fallback.stdout, 'X = bare.', 'unsuffixed fallback source');
+        assertEqual(fallback.stderr, '', 'fallback stderr');
+      },
+    },
+    {
+      name: 'REPL consultation replaces earlier clauses from the same file (issue #46)',
+      run: () => {
+        const filename = path.join(tmp, `repl-reconsult-${++tmpCounter}.pl`);
+        fs.writeFileSync(filename, 'factum(f).\n');
+        const harness = path.join(tmp, `repl-reconsult-harness-${++tmpCounter}.mjs`);
+        const consultedAtom = sourceAtom(filename);
+        fs.writeFileSync(harness, `
+import fs from 'node:fs';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+
+const child = spawn(process.execPath, [${JSON.stringify(bin)}], { stdio: ['pipe', 'pipe', 'pipe'] });
+let stdout = '';
+let stderr = '';
+let advanced = false;
+let failed = false;
+const timer = setTimeout(() => {
+  failed = true;
+  child.kill();
+}, 5000);
+
+child.stdout.setEncoding('utf8');
+child.stderr.setEncoding('utf8');
+child.stdout.on('data', (chunk) => {
+  stdout += chunk;
+  if (!advanced && stdout.includes('?-    true.\\n?- ')) {
+    advanced = true;
+    fs.writeFileSync(${JSON.stringify(filename)}, 'factum(g).\\n');
+    child.stdin.write(\`[${consultedAtom}].\\nfindall(F,factum(F),Fs).\\nhalt.\\n\`);
+  }
+});
+child.stderr.on('data', (chunk) => { stderr += chunk; });
+child.on('close', (code) => {
+  clearTimeout(timer);
+  process.stdout.write(stdout);
+  process.stderr.write(stderr);
+  process.exitCode = failed ? 99 : (code ?? 98);
+});
+child.stdin.write(\`[${consultedAtom}].\\n\`);
+`);
+        const result = spawnSync(process.execPath, [harness], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 7000,
+        });
+        assertEqual(result.error?.code, undefined, 'reconsult harness timeout');
+        assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, 'Fs = \"g\".', 'reconsulted clauses');
+        assertNotIncludes(result.stdout, 'f', 'stale clause removed');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL consult/1 has reconsult semantics',
+      run: () => {
+        const filename = path.join(tmp, `repl-consult-predicate-${++tmpCounter}.pl`);
+        fs.writeFileSync(filename, 'factum(f).\n');
+        const harness = path.join(tmp, `repl-consult-predicate-harness-${++tmpCounter}.mjs`);
+        const consultedAtom = sourceAtom(filename);
+        fs.writeFileSync(harness, `
+import fs from 'node:fs';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+
+const child = spawn(process.execPath, [${JSON.stringify(bin)}], { stdio: ['pipe', 'pipe', 'pipe'] });
+let stdout = '';
+let stderr = '';
+let advanced = false;
+let failed = false;
+const timer = setTimeout(() => {
+  failed = true;
+  child.kill();
+}, 5000);
+
+child.stdout.setEncoding('utf8');
+child.stderr.setEncoding('utf8');
+child.stdout.on('data', (chunk) => {
+  stdout += chunk;
+  if (!advanced && stdout.includes('?-    true.\\n?- ')) {
+    advanced = true;
+    fs.writeFileSync(${JSON.stringify(filename)}, 'factum(g).\\n');
+    child.stdin.write(\`consult(${consultedAtom}).\\nfindall(F,factum(F),Fs).\\nhalt.\\n\`);
+  }
+});
+child.stderr.on('data', (chunk) => { stderr += chunk; });
+child.on('close', (code) => {
+  clearTimeout(timer);
+  process.stdout.write(stdout);
+  process.stderr.write(stderr);
+  process.exitCode = failed ? 99 : (code ?? 98);
+});
+child.stdin.write(\`consult(${consultedAtom}).\\n\`);
+`);
+        const result = spawnSync(process.execPath, [harness], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 7000,
+        });
+        assertEqual(result.error?.code, undefined, 'consult/1 reconsult harness timeout');
+        assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, 'Fs = "g".', 'consult/1 replaced earlier clauses');
+        assertNotIncludes(result.stdout, 'f', 'consult/1 removed stale clause');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL preserves runtime unknown flag across consultation',
       run: () => {
@@ -2002,6 +2139,17 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'statistics/2 rejects unknown keys instead of silently failing (issue #45)',
+      run: () => {
+        const result = runCli([], { input: 'statistics(nonsense, Value).\nhalt.\n' });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout,
+          'error(domain_error(statistics_key, nonsense), eyeprolog).',
+          'statistics key error');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'statistics predicates are excluded from strict ISO mode',
       run: () => {
@@ -2030,6 +2178,21 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'library(lists) length/2 stays relational and call_nth/2 autoloads (issue #28)',
+      run: () => {
+        const input = [
+          ':- use_module(library(lists)).',
+          '%% goal: fourth_length(N)',
+          'fourth_length(N) :- call_nth(length(_Xs, N), 4).',
+          '',
+        ].join('\n');
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'fourth_length(3).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'strict ISO mode disables interop autoloading',
       run: () => {
@@ -3433,10 +3596,11 @@ check(A, B, C, D, E, F) :-
         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, 62, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 26, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
+        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'prologue', 'call_nth/2 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
         assertEqual(eyePrologNativeLibraryIndicators.length, 40, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');

package/the-art-of-eyeprolog.md

@@ -4646,8 +4646,10 @@ where a live snapshot is useful. For example, a long-running loop can include
 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`.
+enumerates the available statistic keys and values. An atom that is not an
+available key raises `domain_error(statistics_key, Key)` rather than silently
+failing. 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
@@ -6037,17 +6039,21 @@ still have an API that is not shared by the other systems.
 `library(lists)` is the first aligned common module. Its interop surface includes
 `member/2`, `memberchk/2`, `select/3`, `append/2-3`, `last/2`,
 `same_length/2`, `nth0/3-4`, `nth1/3-4`, `reverse/2`, `length/2`,
-`maplist/2-8`, `foldl/4-6`, `sum_list/2`, and `list_to_set/2`. EyeProlog-only
-helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4` remain available
-for compatibility but are outside this profile.
+`maplist/2-8`, `foldl/4-6`, `sum_list/2`, and `list_to_set/2`. Its `length/2`
+is fully relational: when both arguments are variables, `length(Xs, N)`
+enumerates `Xs = [], N = 0`, then one-element lists with `N = 1`, and so on.
+This generator mode is important for portable stress and enumeration programs.
+EyeProlog-only helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4`
+remain available for compatibility but are outside this profile.
 
 Normal EyeProlog execution can autoload an otherwise undefined unqualified call
 only when the interop table assigns it one canonical provider. Thus `member/2`
-autoloads from `library(lists)`. `between/3` is also in the interop profile;
-EyeProlog can satisfy it from its internal `library(prologue)` implementation
-without forcing portable source to mention that EyeProlog-specific library
-name. Autoloading is disabled by `--no-autoload`, by the JavaScript option
-`autoload: false`, and always by `--iso-strict`.
+autoloads from `library(lists)`. `between/3` and `call_nth/2` are also in the
+interop profile; EyeProlog can satisfy them from its internal
+`library(prologue)` implementation without forcing portable source to mention
+that EyeProlog-specific library name. Autoloading is disabled by
+`--no-autoload`, by the JavaScript option `autoload: false`, and always by
+`--iso-strict`.
 
 `-w` / `--warnings` reports explicit non-profile library dependencies and calls
 to non-profile predicates from common libraries. `--portable` turns those
@@ -6395,8 +6401,14 @@ not be a valid right operand of the displayed `=/2`, EyeProlog adds parentheses,
 for example `T = (a = b).` rather than the invalid `T = a = b.`. When an answer
 ends in a graphic token, the top level inserts layout before its terminating
 full stop so the two tokens cannot merge; for example `?- X = .* .` displays
-`X = .* .`, not `X = .*.`. Use `[file].` or `['file.pl'].` to
-consult local source, and `halt.` or `halt(Status).` to leave the top level.
+`X = .* .`, not `X = .*.`. Use `[file].`, `['file.pl'].`, or
+`consult(file).` to consult local source; `reconsult(file).` is accepted as a
+compatibility alias. Use `halt.` or `halt(Status).` to leave the top level.
+For an extensionless designation such as `[file].` or `consult(file).`, the
+top level tries `file.pl` before the unsuffixed `file`. Both the shorthand and
+`consult/1` have modern reconsult semantics: consulting the same resolved file
+again replaces its previous source, so clauses removed from the file do not
+remain active.
 When `read/1-2` or `read_term/2-3` actually reaches interactive
 `user_input`, the top level requests the next full-stop-terminated Prolog term
 with a `|: ` input prompt instead of treating the terminal stream as already