eyeprolog 1.2.21 → 1.2.23

package/package.json

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

package/src/iso.js

@@ -5,7 +5,8 @@ import {
   isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble,
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
-import { createParserOperatorState, parseClauses, parseGoalText } from './parser.js';
+import { sameNumberValue } from './number-value.js';
+import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 
@@ -220,7 +221,8 @@ function subsumesTerm(general, specific, env) {
       }
       continue;
     }
-    if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+    if (left.type !== right.type || left.arity !== right.arity) return false;
+    if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
     for (let i = left.arity - 1; i >= 0; i--) pending.push([left.args[i], right.args[i]]);
   }
   return true;
@@ -239,7 +241,8 @@ function* nonIdentity({ goal, env }) {
 function identical(left, right, env) {
   left = deref(left, env);
   right = deref(right, env);
-  if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+  if (left.type !== right.type || left.arity !== right.arity) return false;
+  if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
   if (left.type === VAR) return left.name === right.name;
   for (let i = 0; i < left.arity; i++) if (!identical(left.args[i], right.args[i], env)) return false;
   return true;
@@ -1549,9 +1552,7 @@ function quotedNumberSign(text, start) {
 }
 
 function parseIsoNumber(text) {
-  // number_chars/2 accepts leading layout, but its character list must end
-  // with the numeric token itself rather than trailing layout text.
-  if (text.length === 0 || /[\u0009-\u000d\u0020]$/.test(text)) return null;
+  if (text.length === 0) return null;
   let position = skipNumberLayout(text, 0);
   let sign = '';
 
@@ -1587,10 +1588,7 @@ function parseIsoNumber(text) {
   // ISO floating-point syntax requires a decimal fraction before an exponent.
   if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
   try {
-    const parsed = parseGoalText(`number_chars_value(${numericText})`);
-    if (parsed.type !== COMPOUND || parsed.name !== 'number_chars_value' ||
-        parsed.arity !== 1 || parsed.args[0].type !== NUMBER) return null;
-    const value = parsed.args[0];
+    const value = parseNumberTokenText(numericText);
     if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
     const finite = Number(value.name);
     if (!Number.isFinite(finite)) return null;
@@ -1601,14 +1599,18 @@ function parseIsoNumber(text) {
 }
 
 function sameNumber(left, right) {
-  const leftInteger = isDecimalInteger(left.name);
-  const rightInteger = isDecimalInteger(right.name);
-  if (leftInteger || rightInteger) {
-    return leftInteger && rightInteger && BigInt(left.name) === BigInt(right.name);
+  return sameNumberValue(left.name, right.name);
+}
+
+function canonicalNumberText(value) {
+  if (isDecimalInteger(value.name)) return BigInt(value.name).toString();
+  const finite = Number(value.name);
+  if (Number.isFinite(finite) && /^-?\d+\.\d+(?:[eE][+-]?\d+)?$/.test(value.name)) {
+    return value.name;
   }
-  const leftValue = Number(left.name);
-  const rightValue = Number(right.name);
-  return Number.isFinite(leftValue) && Number.isFinite(rightValue) && leftValue === rightValue;
+  const text = numberTextFromDouble(finite);
+  if (text == null) throw new PrologError('representation_error(max_float)');
+  return text;
 }
 
 function numberListText(list, env, kind, valueIsBound) {
@@ -1650,7 +1652,7 @@ function numberListBuiltin(kind) {
         if (sameNumber(value, parsed)) yield next;
         return;
       }
-      const items = characters(value.name).map((ch) =>
+      const items = characters(canonicalNumberText(value)).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;

package/src/number-value.js

@@ -0,0 +1,28 @@
+// Numeric value identity shared by term semantics and scalar indexes. Keep
+// integer and float terms distinct while ignoring insignificant spelling
+// differences within either ISO numeric type.
+const decimalInteger = (text) => /^-?\d+$/.test(text ?? '');
+
+const finiteFloat = (text) => {
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text ?? '')) return null;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : null;
+};
+
+export function sameNumberValue(left, right) {
+  const leftInteger = decimalInteger(left);
+  const rightInteger = decimalInteger(right);
+  if (leftInteger || rightInteger) {
+    return leftInteger && rightInteger && BigInt(left) === BigInt(right);
+  }
+  const leftValue = finiteFloat(left);
+  const rightValue = finiteFloat(right);
+  return leftValue != null && rightValue != null && leftValue === rightValue;
+}
+
+export function numberValueKey(text) {
+  if (decimalInteger(text)) return `integer:${BigInt(text)}`;
+  const value = finiteFloat(text);
+  if (value == null) return `invalid:${text}`;
+  return `float:${Object.is(value, -0) ? 0 : value}`;
+}

package/src/parser.js

@@ -433,6 +433,18 @@ class Parser {
         this.take();
         this.take();
         let value = this.take();
+        if (value) {
+          const firstCode = value.charCodeAt(0);
+          if (firstCode >= 0xd800 && firstCode <= 0xdbff) {
+            const secondCode = this.peek().charCodeAt(0);
+            if (secondCode < 0xdc00 || secondCode > 0xdfff) {
+              throw new Error(`parse line ${line}: bad character code constant`);
+            }
+            value += this.take();
+          } else if (firstCode >= 0xdc00 && firstCode <= 0xdfff) {
+            throw new Error(`parse line ${line}: bad character code constant`);
+          }
+        }
         if (!value || (value !== ' ' && isWhitespaceCode(value.charCodeAt(0)))) {
           throw new Error(`parse line ${line}: bad character code constant`);
         }
@@ -1294,6 +1306,22 @@ export function parseProgramText(source, options = {}) {
   return parseClauses(source, options);
 }
 
+export function parseNumberTokenText(text) {
+  const source = String(text ?? '');
+  const parser = new Parser(source, {
+    includeDefaultOperators: false,
+    sourceMetadata: false,
+  });
+  // Inspect the tokenizer position before requesting another token: advancing
+  // would skip trailing layout and make `3 ` or `3/**/` look complete. A
+  // literal space consumed by the character-code token `0' ` is already part
+  // of parser.pos and is therefore correctly accepted.
+  if (parser.token.type !== TOK.NUMBER || parser.pos !== source.length) {
+    throw new Error('not exactly one number token');
+  }
+  return numberTerm(parser.token.text);
+}
+
 export function parseGoalText(text, options = {}) {
   const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;

package/src/program.js

@@ -1,6 +1,7 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
 import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
+import { numberValueKey } from './number-value.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
@@ -1238,15 +1239,19 @@ function scalarBuckets(index, term) {
 }
 
 function argumentBucket(index, term) {
-  return scalarBuckets(index, term).get(term.name) ?? null;
+  return scalarBuckets(index, term).get(scalarBucketKey(term.type, term.name)) ?? null;
 }
 
 function addArgumentBucket(index, term, clause) {
-  addClauseBucket(scalarBuckets(index, term), term.name, clause);
+  addClauseBucket(scalarBuckets(index, term), scalarBucketKey(term.type, term.name), clause);
 }
 
 function scalarIndexKey(term) {
-  return `${term.type}\u0000${term.name}`;
+  return `${term.type}\u0000${scalarBucketKey(term.type, term.name)}`;
+}
+
+function scalarBucketKey(type, name) {
+  return type === 'number' ? numberValueKey(name) : name;
 }
 
 function addClauseBucket(buckets, key, clause) {
@@ -1276,7 +1281,7 @@ function indexCompactOne(index, type, name, clause, clauses = null, clausePositi
       index.sawScalar = true;
       if (clauses && clausePosition > 0) index.fallback = clauses.slice(0, clausePosition);
     }
-    addClauseBucket(compactScalarBuckets(index, type), name, clause);
+    addClauseBucket(compactScalarBuckets(index, type), scalarBucketKey(type, name), clause);
   } else if (index.sawScalar) {
     index.fallback.push(clause);
   }

package/src/repl.js

@@ -31,13 +31,23 @@ export async function runRepl(engine, options = {}) {
       if (text == null) break;
       if (!text.trim()) continue;
 
+      let resultIndent = '   ';
       try {
         const goal = parseGoal(engine, state, text);
+        // A complete, successfully parsed query has left the top-level reader
+        // and is about to execute. Show two spaces immediately so a terminal
+        // user can distinguish that state from a reader waiting for more text;
+        // the final result adds the third indentation space below. A direct
+        // halt has no result and exits immediately, so it needs no marker.
+        if (!isHaltGoal(goal)) {
+          output.write('  ');
+          resultIndent = ' ';
+        }
         if (!options.isoStrict && isUseModuleGoal(goal)) {
           sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
           state = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
-          output.write('   true.\n');
+          output.write(' true.\n');
           continue;
         }
         const consultFiles = options.isoStrict ? null : consultDesignations(engine, goal);
@@ -45,7 +55,7 @@ export async function runRepl(engine, options = {}) {
           for (const filename of consultFiles) sources.push(await readSource(filename));
           state = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
-          output.write('   true.\n');
+          output.write(' true.\n');
           continue;
         }
 
@@ -65,7 +75,7 @@ export async function runRepl(engine, options = {}) {
           exitCode = error.code;
           break;
         }
-        output.write(`   ${formatError(engine, state, error)}\n`);
+        output.write(`${resultIndent}${formatError(engine, state, error)}\n`);
       }
     }
   } catch (error) {
@@ -442,6 +452,11 @@ function isUseModuleGoal(goal) {
   return goal.type === 'compound' && goal.name === 'use_module' && [1, 2].includes(goal.arity);
 }
 
+function isHaltGoal(goal) {
+  return (goal.type === 'atom' && goal.name === 'halt') ||
+    (goal.type === 'compound' && goal.name === 'halt' && goal.arity === 1);
+}
+
 function consultDesignations(engine, goal) {
   if (goal.type === 'atom' && goal.name === '[]') return [];
   if (goal.type !== 'compound' || goal.name !== '.' || goal.arity !== 2) return null;
@@ -481,7 +496,7 @@ async function solveQuery(engine, state, goal, reader, output) {
   }
 
   if (current.result.done) {
-    output.write('   false.\n');
+    output.write(' false.\n');
     return null;
   }
 
@@ -498,7 +513,7 @@ async function solveQuery(engine, state, goal, reader, output) {
     if (formattingAfterAdvance) output.write(' ');
     formattingAfterAdvance = false;
     output.write(current.output);
-    output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
+    output.write(`${firstAnswer ? ' ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
     answersShown++;
     firstAnswer = false;
     if (!next.error && next.result.done) {

package/src/solver.js

@@ -4,6 +4,7 @@ import {
   COMPOUND, Env, compound, copyResolved, deref, emptyList, flattenConjunction, freshTerm,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variantTerms,
 } from './term.js';
+import { sameNumberValue } from './number-value.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
@@ -1089,11 +1090,13 @@ function isScalarTerm(term) {
 }
 
 function sameScalarTerm(left, right) {
-  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type && left.name === right.name;
+  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type &&
+    (left.type === 'number' ? sameNumberValue(left.name, right.name) : left.name === right.name);
 }
 
 function sameGroundTerm(left, right) {
-  if (left?.type !== right?.type || left?.name !== right?.name) return false;
+  if (left?.type !== right?.type) return false;
+  if (left?.type === 'number' ? !sameNumberValue(left.name, right.name) : left?.name !== right?.name) return false;
   const arity = left.args?.length ?? 0;
   if (arity !== (right.args?.length ?? 0)) return false;
   for (let i = 0; i < arity; i++) if (!sameGroundTerm(left.args[i], right.args[i])) return false;

package/src/term.js

@@ -1,5 +1,7 @@
 // Term model, environments, unification, readback, and ordering helpers.
-// This file is intentionally dependency-free because nearly every other module imports it.
+// Keep dependencies minimal because nearly every other module imports this file.
+import { sameNumberValue } from './number-value.js';
+
 export const VAR = 'var';
 export const ATOM = 'atom';
 export const STRING = 'string';
@@ -247,7 +249,7 @@ export function unify(left, right, env, options = {}) {
     }
 
     if (isScalar(a)) {
-      if (a.name !== b.name) return false;
+      if (a.type === NUMBER ? !sameNumberValue(a.name, b.name) : a.name !== b.name) return false;
       continue;
     }
 
@@ -497,7 +499,8 @@ export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(),
     reverse.set(right.name, left.name);
     return true;
   }
-  if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+  if (left.type !== right.type || left.arity !== right.arity) return false;
+  if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
   for (let i = 0; i < left.arity; i++) {
     if (!variantTerms(left.args[i], leftEnv, right.args[i], rightEnv, pairs, reverse)) return false;
   }

package/test/run-regression.mjs

@@ -567,6 +567,63 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'number conversion accepts ISO space and Unicode character-code constants exactly',
+      run: () => {
+        const source = String.raw`
+?- N = 0' .
+   N = 32.
+?- number_chars(N,"0' ").
+   N = 32.
+?- number_codes(N,[48,39,32]).
+   N = 32.
+?- N = 0'😀.
+   N = 128512.
+?- number_chars(N,"0'😀").
+   N = 128512.
+?- number_codes(N,[48,39,128512]).
+   N = 128512.
+?- number_codes(N,[48,39,34]).
+   N = 34.
+?- number_codes(N,[48,39,96]).
+   N = 96.
+?- number_codes(N,[48,39,92,92]).
+   N = 92.
+?- number_chars(01,Chars).
+   Chars = "1".
+?- number_codes(01,Codes).
+   Codes = [49].
+?- 1.2 = 1.20.
+   true.
+?- 1.2 == 1.20.
+   true.
+?- 1 = 1.0.
+   false.
+?- number_chars(1.20,C), number_chars(Y,C), 1.20 == Y.
+   C = "1.20", Y = 1.2.
+`;
+        const result = publicApi.runQuads(source);
+        assertEqual(result.total, 15, 'quad total');
+        assertEqual(result.passed, 15, 'quad passed');
+        assertEqual(result.stdout, 'quads: 15 run, 15 passed, 0 failed.\n', 'quad report');
+
+        for (const goal of [
+          'number_chars(N,"3/**/")',
+          'number_codes(N,[51,47,42,42,47])',
+          'number_chars(N,"0\'  ")',
+          'number_codes(N,[48,39,32,32])',
+        ]) {
+          let caught = null;
+          try {
+            publicApi.run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          if (caught == null) throw new Error(`${goal} should reject trailing layout`);
+          assertIncludes(String(caught?.message ?? caught), 'syntax_error(number)', goal);
+        }
+      },
+    },
     {
       name: 'number conversion rejects parenthesized numeric terms',
       run: () => {
@@ -820,7 +877,7 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'REPL answer prompt distinguishes waiting from computation',
+      name: 'REPL query and answer prompts distinguish waiting from computation',
       run: () => {
         const helper = `
           import { spawn } from 'node:child_process';
@@ -833,9 +890,11 @@ c4 ?- call((!;1)).
           child.stderr.setEncoding('utf8');
           let stdout = '';
           let stderr = '';
+          let sawQueryComputingPrompt = false;
           let sawComputingPrompt = false;
           child.stdout.on('data', (text) => {
             stdout += text;
+            if (stdout.endsWith('?-   ')) sawQueryComputingPrompt = true;
             if (stdout.endsWith('\\n; ')) sawComputingPrompt = true;
           });
           child.stderr.on('data', (text) => { stderr += text; });
@@ -852,6 +911,10 @@ c4 ?- call((!;1)).
 
           child.stdin.write('use_module(library(prologue)).\\n');
           await waitFor(() => stdout.includes('   true.\\n?- '), 'module import');
+          sawQueryComputingPrompt = false;
+          child.stdin.write('between(0,0xff,I),I<0.\\n');
+          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');
           child.stdin.write(';\\n');
@@ -862,7 +925,7 @@ c4 ?- call((!;1)).
           child.stdin.write('halt.\\n');
           const status = await new Promise((resolve) => child.once('exit', resolve));
           if (status !== 0) throw new Error('child status ' + status + '; stderr=' + stderr);
-          process.stdout.write('waiting;computing;formatting');
+          process.stdout.write('query-computing;waiting;computing;formatting');
         `;
         const result = spawnSync(process.execPath, [
           '--input-type=module',
@@ -871,7 +934,7 @@ c4 ?- call((!;1)).
         ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
         if (result.error) throw result.error;
         assertEqual(result.status, 0, `prompt helper status; stderr=${result.stderr}`);
-        assertEqual(result.stdout, 'waiting;computing;formatting', 'prompt state sequence');
+        assertEqual(result.stdout, 'query-computing;waiting;computing;formatting', 'prompt state sequence');
       },
     },
     {
@@ -941,9 +1004,9 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          "?- '\\a'   true.\n" +
-          "?- '\\a'   true.\n" +
-          "?- '\\a'   true.\n" +
+          "?-   '\\a' true.\n" +
+          "?-   '\\a' true.\n" +
+          "?-   '\\a' true.\n" +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -956,7 +1019,7 @@ c4 ?- call((!;1)).
           input: "writeq('\\0\\').\nhalt.\n",
         });
         assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, "?- '\\0\\'   true.\n?- ", 'stdout');
+        assertEqual(result.stdout, "?-   '\\0\\' true.\n?- ", 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -1091,7 +1154,7 @@ c4 ?- call((!;1)).
           input: "writeq('\\033\\').\nhalt.\n",
         });
         assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, "?- '\\33\\'   true.\n?- ", 'stdout');
+        assertEqual(result.stdout, "?-   '\\33\\' true.\n?- ", 'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -1110,9 +1173,9 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?- |:    X = foo.\n' +
-          "?- |:    Y = '\\a'.\n" +
-          '?- |:    Z = bar.\n' +
+          '?-   |:  X = foo.\n' +
+          "?-   |:  Y = '\\a'.\n" +
+          '?-   |:  Z = bar.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');

package/the-art-of-eyeprolog.md

@@ -5777,7 +5777,13 @@ therefore follow `-` directly because `%` cannot continue a graphic token; an
 adjacent bracketed comment in `-/**/1` remains a syntax error under the eager
 token-consumer rule. Decimal fractions and decimal exponents are supported;
 the apostrophe character code is written with a doubled apostrophe as `0'''`
-and has value 39. Trailing material and non-finite values are rejected. The
+and has value 39, while a literal space character code is `0' ` and has value
+32. Character-code constants consume one Unicode scalar, including a
+non-BMP character. Trailing layout, comments, and other material are rejected;
+bound integers are converted to their canonical decimal spelling, and
+non-finite values are rejected. Equivalent spellings of the same numeric type
+compare by value, preserving the standard conversion round trip, while integer
+and floating-point terms remain distinct. The
 regression gate vendors all 74 numbered cases from Ulrich Neumerkel's contemporary
 `number_chars/2` comparison, including the Cor.2 error-precedence cases;
 `number_codes/2` shares the same numeric parser and has mirrored coverage for
@@ -6285,10 +6291,13 @@ 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. 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 formatting. While a query is actively
-computing, EyeProlog releases readline's terminal signal handling: `Ctrl-C`
+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
+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
+formatting. 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
 host top-level convention rather than an ISO/IEC 13211-1 language feature. A