eyeprolog 1.3.1 → 1.3.3

package/package.json

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

package/src/iso.js

@@ -6,7 +6,7 @@ import {
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { sameNumberValue } from './number-value.js';
-import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
+import { createParserOperatorState, parseGoalText, parseNumberTokenText, parseTermText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import {
@@ -1199,8 +1199,7 @@ function scopeReadTerm(term) {
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-  const clauses = parseClauses(converted, {
-    sourceMetadata: false,
+  return parseTermText(converted, {
     operatorState,
     isoStrict: solver.isoStrict,
     doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
@@ -1208,8 +1207,6 @@ function parseReadTermText(text, solver) {
     // Earlier ambiguous dots must remain available to maximal graphic tokens.
     readTermEnd: converted.length - 1,
   });
-  if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
-  return clauses[0].head;
 }
 
 export function isCompleteReadTermText(text, solver) {

package/src/parser.js

@@ -819,6 +819,16 @@ class Parser {
     }
     throw new Error(`parse line ${this.token.line}: bad term`);
   }
+  parseStandaloneTerm() {
+    // read/1 and read_term/* consume one ordinary Prolog term, not a program
+    // clause. In particular, commas and operators such as :- and ?- belong to
+    // the term itself and must not be reinterpreted by parseProgram().
+    const term = this.parseTerm(0, true, true, true);
+    this.expect(TOK.DOT, '.');
+    this.advance();
+    this.expect(TOK.EOF, 'end of input');
+    return term;
+  }
   sourceLineIsIndented(line) {
     let start = 0;
     for (let current = 1; current < line; current++) {
@@ -1504,6 +1514,10 @@ export function parseNumberTokenText(text) {
   return numberTerm(source);
 }
 
+export function parseTermText(text, options = {}) {
+  return new Parser(text, options).parseStandaloneTerm();
+}
+
 export function parseGoalText(text, options = {}) {
   const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;

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

@@ -154,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

@@ -819,6 +819,27 @@ c4 ?- call((!;1)).
         });
         assertEqual(consecutive.stdout, "answer(./*., ok).\n", 'following read starts after the complete term');
 
+        // Issue #41 follow-up: read/1 consumes an ordinary term, not a program
+        // clause head. A comma chain therefore has no program-level two-comma
+        // limit, and source operators such as :- and ?- remain term data.
+        const commaChain = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '!,!,! .\n' },
+        });
+        assertEqual(commaChain.stdout, 'read((!, !, !)).\n', 'three-element comma term');
+
+        const ruleAsData = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: 'a :- b.\n' },
+        });
+        assertEqual(ruleAsData.stdout, 'read((a :- b)).\n', 'rule operator remains term data');
+
+        const queryAsData = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '?- foo.\n' },
+        });
+        assertEqual(queryAsData.stdout, 'read((?- foo)).\n', 'query operator remains term data');
+
         // A possible full stop can fail to complete the term while still
         // extending a current graphic operator into an ordinary atom.  The
         // later standalone full stop then completes the read term.  Exercise
@@ -1712,6 +1733,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 +2160,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: () => {

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
@@ -6399,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