eyeprolog 1.5.23 → 1.5.25

package/examples/odrl-policy-reasoning.pl

@@ -345,11 +345,11 @@ profile_prohibition(Request) :-
   cycle_request(Request),
   tnot(profile_permission(Request)).
 
-% For a ground WFS claim, both Claim and tnot(Claim) conditionally succeed when
-% the truth value is undefined.  That lets this example expose all three states.
+% For a ground WFS claim, true and false are successful positive and negative
+% probes.  If neither probe succeeds, the WFS truth value is undefined.
 wfs_truth(Claim, true) :- call(Claim), \+ tnot(Claim).
 wfs_truth(Claim, false) :- tnot(Claim), \+ call(Claim).
-wfs_truth(Claim, undefined) :- call(Claim), tnot(Claim).
+wfs_truth(Claim, undefined) :- \+ call(Claim), \+ tnot(Claim).
 
 % --- Curated questions -----------------------------------------------------
 

package/index.d.ts

@@ -1,7 +1,7 @@
 export interface EyePrologStats {
   /** Alternating-fixed-point rounds used to build WFS models. */
   wfs_fixpoint_rounds: number;
-  /** Undefined WFS answers observed while producing query results. */
+  /** Undefined WFS atoms encountered while resolving query goals. */
   wfs_undefined_answers: number;
   [key: string]: number;
 }

package/package.json

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

package/src/iso.js

@@ -1762,7 +1762,7 @@ function parseReadTermText(text, solver) {
   const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
   let numericTerm;
   try {
-    numericTerm = parseIsoNumber(numericText);
+    numericTerm = parseIsoNumber(numericText, { isoStrict: solver.isoStrict });
   } catch (error) {
     // parseIsoNumber/1 exposes Prolog errors to number_chars/2. The stream
     // reader's candidate loop instead recognizes parser representation errors
@@ -2338,7 +2338,7 @@ function quotedNumberSign(text, start) {
   return null;
 }
 
-function parseIsoNumber(text) {
+function parseIsoNumber(text, options = {}) {
   if (text.length === 0) return null;
   let position = skipNumberLayout(text, 0);
   let sign = '';
@@ -2375,7 +2375,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 value = parseNumberTokenText(numericText);
+    const value = parseNumberTokenText(numericText, options);
     if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
     const finite = Number(value.name);
     if (!Number.isFinite(finite)) return null;
@@ -2447,7 +2447,7 @@ function numberListBuiltin(kind) {
     const text = numberListText(list, env, kind, value.type === NUMBER, solver);
     if (value.type === NUMBER) {
       if (text != null) {
-        const parsed = parseIsoNumber(text);
+        const parsed = parseIsoNumber(text, { isoStrict: solver?.isoStrict === true });
         if (parsed == null) throw numberSyntaxError;
         if (sameNumber(value, parsed)) yield env.clone();
         return;
@@ -2458,7 +2458,7 @@ function numberListBuiltin(kind) {
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    const parsed = parseIsoNumber(text);
+    const parsed = parseIsoNumber(text, { isoStrict: solver?.isoStrict === true });
     if (parsed == null) throw numberSyntaxError;
     const next = env.clone();
     if (unify(goal.args[0], parsed, next)) yield next;

package/src/parser.js

@@ -439,6 +439,21 @@ class Parser {
       break;
     }
   }
+  integerDigits(digitPattern, line) {
+    let digits = '';
+    let separated = false;
+    while (digitPattern.test(this.peek())) {
+      digits += this.take();
+      if (this.strictIso || this.peek() !== '_') continue;
+      separated = true;
+      this.take();
+      this.skipWhitespaceAndComments();
+      if (!digitPattern.test(this.peek())) {
+        throw new Error(`parse line ${line}: bad digit separator`);
+      }
+    }
+    return { digits, separated };
+  }
   readEscape(line, options = {}) {
     const takeChar = () => options.raw ? this.rawTake() : this.take();
     const peekChar = () => options.raw ? this.rawPeek() : this.peek();
@@ -646,17 +661,16 @@ class Parser {
         const kind = this.take();
         const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
         const digitPattern = radix === 2 ? /^[01]$/ : radix === 8 ? /^[0-7]$/ : /^[0-9A-Fa-f]$/;
-        let digits = '';
-        while (digitPattern.test(this.peek())) digits += this.take();
+        const { digits } = this.integerDigits(digitPattern, line);
         if (!digits) throw new Error(`parse line ${line}: bad radix integer`);
         let integer = 0n;
         for (const digit of digits) integer = integer * BigInt(radix) + BigInt(Number.parseInt(digit, radix));
         if (negative) integer = -integer;
         return { type: TOK.NUMBER, text: integer.toString(), line };
       }
-      while (isDigitCode(this.peek().charCodeAt(0))) this.take();
+      const { digits, separated } = this.integerDigits(/^[0-9]$/, line);
       let hasFraction = false;
-      if (this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
+      if (!separated && this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
         hasFraction = true;
         this.take();
         while (isDigitCode(this.peek().charCodeAt(0))) this.take();
@@ -674,7 +688,7 @@ class Parser {
         }
       }
       let text = this.convertedSlice(start, this.pos);
-      if (!hasFraction) text = BigInt(text).toString();
+      if (!hasFraction) text = BigInt(`${negative ? '-' : ''}${digits}`).toString();
       else text = finiteFloatTokenText(text);
       return { type: TOK.NUMBER, text, line };
     }
@@ -1704,8 +1718,43 @@ export function parseProgramText(source, options = {}) {
 
 const invalidNumberTokenError = new Error('not exactly one number token');
 
-export function parseNumberTokenText(text) {
+function skipDigitSeparatorLayout(source, start) {
+  let position = start;
+  while (true) {
+    while (isWhitespaceCharacter(source[position] ?? '')) position++;
+    if (source[position] === '%') {
+      const newline = source.indexOf('\n', position + 1);
+      if (newline < 0) return source.length;
+      position = newline + 1;
+      continue;
+    }
+    if (source.startsWith('/*', position)) {
+      const end = source.indexOf('*/', position + 2);
+      if (end < 0) return source.length;
+      position = end + 2;
+      continue;
+    }
+    return position;
+  }
+}
+
+function separatedIntegerDigits(source, start, digitPattern, enabled) {
+  let position = start;
+  let digits = '';
+  let separated = false;
+  while (digitPattern.test(source[position] ?? '')) {
+    digits += source[position++];
+    if (!enabled || source[position] !== '_') continue;
+    separated = true;
+    position = skipDigitSeparatorLayout(source, position + 1);
+    if (!digitPattern.test(source[position] ?? '')) throw invalidNumberTokenError;
+  }
+  return { digits, position, separated };
+}
+
+export function parseNumberTokenText(text, options = {}) {
   const source = String(text ?? '');
+  const digitSeparators = options.isoStrict !== true;
   let position = 0;
   let negative = false;
   if (source[position] === '-') {
@@ -1771,8 +1820,9 @@ export function parseNumberTokenText(text) {
     const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
     const digitPattern = radix === 2 ? /^[01]$/ : radix === 8 ? /^[0-7]$/ : /^[0-9A-Fa-f]$/;
     position += 2;
-    let digits = '';
-    while (digitPattern.test(source[position] ?? '')) digits += source[position++];
+    const scanned = separatedIntegerDigits(source, position, digitPattern, digitSeparators);
+    const { digits } = scanned;
+    position = scanned.position;
     if (!digits || position !== source.length) throw invalidNumberTokenError;
     let integer = 0n;
     for (const digit of digits) integer = integer * BigInt(radix) + BigInt(Number.parseInt(digit, radix));
@@ -1780,11 +1830,12 @@ export function parseNumberTokenText(text) {
     return numberTerm(integer.toString());
   }
 
-  const digitsStart = position;
-  while (isDigitCode(source.charCodeAt(position))) position++;
-  if (position === digitsStart) throw invalidNumberTokenError;
+  const scanned = separatedIntegerDigits(source, position, /^[0-9]$/, digitSeparators);
+  const { digits, separated } = scanned;
+  position = scanned.position;
+  if (!digits) throw invalidNumberTokenError;
   let hasFraction = false;
-  if (source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
+  if (!separated && source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
     hasFraction = true;
     position++;
     while (isDigitCode(source.charCodeAt(position))) position++;
@@ -1797,7 +1848,7 @@ export function parseNumberTokenText(text) {
     if (position === exponentStart) throw invalidNumberTokenError;
   }
   if (position !== source.length) throw invalidNumberTokenError;
-  if (/^-?\d+$/.test(source)) return numberTerm(BigInt(source).toString());
+  if (!hasFraction) return numberTerm(BigInt(`${negative ? '-' : ''}${digits}`).toString());
   return numberTerm(finiteFloatTokenText(source));
 }
 

package/src/solver.js

@@ -909,7 +909,10 @@ export class Solver {
         if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
       }
       if (!ok) continue;
-      if (!lower?.has(row)) this.stats.wfs_undefined_answers++;
+      if (!lower?.has(row)) {
+        this.stats.wfs_undefined_answers++;
+        continue;
+      }
       yield* this.solve(rest, next, depth + 1);
       if (this.solutionsSeen >= this.solutionLimit) return;
     }
@@ -927,7 +930,10 @@ export class Solver {
       const model = this.wfsModelFor(group);
       const truth = truthOfGroundGoal(model, invoked);
       if (truth === 'true') return;
-      if (truth === 'undefined') this.stats.wfs_undefined_answers++;
+      if (truth === 'undefined') {
+        this.stats.wfs_undefined_answers++;
+        return;
+      }
       yield env;
       return;
     }
@@ -1523,7 +1529,10 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
       if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
     }
     if (!ok) continue;
-    if (!lower?.has(row)) solver.stats.wfs_undefined_answers++;
+    if (!lower?.has(row)) {
+      solver.stats.wfs_undefined_answers++;
+      continue;
+    }
     stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
   }
 }

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -113,7 +113,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 
 | Part 1 extension hook | EyeProlog normal-profile feature | Strict-core disposition |
 | --- | --- | --- |
-| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, digit-separated integer constants (`1_000`, `0xCA_FE`, with optional layout after `_`), and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax, integer digit separators, and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |

package/test/conformance/ISO-PROCESSOR-REQUIREMENTS.md

@@ -34,7 +34,7 @@ certification claim.
 | Requirement | Status | EyeProlog decision / evidence |
 | --- | --- | --- |
 | 5.5 general extension rule | covered | normal mode may provide documented extensions; strict mode removes their Part 1 interpretation rather than changing implementation-defined choices |
-| 5.5.1 syntax extensions preserve standard token/text meaning | covered | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation. Every vendored WG17 case that succeeds in the strict reader has the same observable outcome in normal mode; the focused Clause 6 gate separately covers each standard token/term family and malformed counterparts. |
+| 5.5.1 syntax extensions preserve standard token/text meaning | covered | WG17 syntax is a release gate and strict mode removes module/DCG/quad, digit-separator, and double-bar interpretation. Every vendored WG17 case that succeeds in the strict reader has the same observable outcome in normal mode; the focused Clause 6 gate separately covers each standard token/term family and malformed counterparts. |
 | 5.5.2 additional predefined operators | covered | strict mode starts from the Part 1 predefined operator table; normal-profile extra operators are documented and filtered |
 | 5.5.3 initial character-conversion mapping | covered | identity initial mapping; user changes are exercised through preparation/execution `char_conversion/2` behavior |
 | 5.5.4 additional term types | covered | the normal JavaScript API's `stringTerm(Text)` is documented as an implementation-specific sixth term type, including disjointness, ordering, clause conversion, lack of source token syntax, expression behavior, and writing; strict program/goal entry rejects that type with `representation_error(term)` |

package/test/run-regression.mjs

@@ -7252,6 +7252,54 @@ function whiteBoxCases() {
         }
       },
     },
+    {
+      name: 'normal integer syntax accepts WG17 digit separators (issue #89)',
+      run: () => {
+        const values = parseGoalText(`values(
+          1_000,
+          0b1010_0101,
+          0o7_ 7,
+          0xCA_/* digit group */FE,
+          -9_% line group
+          223
+        )`).args;
+        assertEqual(values.map((value) => value.name).join(','), '1000,165,63,51966,-9223',
+          'decimal and radix separator values');
+        const program = Program.parse('decimal(1_000).\nhexadecimal(0xCA_FE).\n');
+        assertEqual(program.findGroup('decimal', 1)?.clauses[0].head.args[0].name, '1000',
+          'program decimal literal');
+        assertEqual(program.findGroup('hexadecimal', 1)?.clauses[0].head.args[0].name, '51966',
+          'program radix literal');
+        assertEqual(parseNumberTokenText('1_ /* group */ 000').name, '1000',
+          'number-token conversion with layout');
+        assertEqual(
+          run('', { goal: 'number_chars(N,"1_000")' }).stdout,
+          'number_chars(1000, "1_000").\n',
+          'normal number_chars input',
+        );
+        assertEqual(
+          run('', { goal: 'read_term(N, [])', ioOptions: { input: '1_ /* group */ 000. ' } }).stdout,
+          'read_term(1000, []).\n',
+          'stream term input',
+        );
+
+        for (const source of ['1__000', '1_', '1_a', '0b1_2', '1_1.25', '1.2_5', '1.0e1_0']) {
+          let threw = false;
+          try { parseGoalText(`p(${source})`); } catch (_) { threw = true; }
+          assertEqual(threw, true, `malformed or non-integer separator rejected: ${source}`);
+        }
+
+        for (const source of ['1_000', '0b1010_0101', '0o7_7', '0xCA_FE']) {
+          let threw = false;
+          try { parseGoalText(`p(${source})`, { isoStrict: true }); } catch (_) { threw = true; }
+          assertEqual(threw, true, `strict syntax rejects ${source}`);
+        }
+        let strictConversion = null;
+        try { run('', { isoStrict: true, goal: 'number_chars(N,"1_000")' }); }
+        catch (error) { strictConversion = error; }
+        assertEqual(strictConversion?.formal, 'syntax_error(number)', 'strict number_chars rejection');
+      },
+    },
     {
       name: 'double_quotes(true) remains effective with ignore_ops(true) in either option order (issue #88 follow-up)',
       run: () => {
@@ -7734,9 +7782,9 @@ win(X) :- move(X, Y), tnot(win(Y)).
         assertEqual(program.findGroup('win', 1).wfsDatalog, true, 'win/1 uses finite WFS evaluation');
         assertEqual(program.findGroup('win', 1).tabled, false, 'win/1 is not positive least-model tabled');
         const result = run(program, { goal: 'win(X)' });
-        assertEqual(result.stdout.trim().split('\n').length, 4, 'negative cycle yields four conditional WFS answers');
+        assertEqual(result.stdout, '', 'negative cycle does not expose undefined atoms as successful answers');
         assertEqual(result.stats.wfs_fixpoint_rounds, 2, 'alternating fixed point converges in two rounds');
-        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle answers are undefined rather than unconditional truths');
+        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle atoms are observed as undefined rather than unconditional truths');
 
         const nafProgram = Program.parse('p(X) :- \\+ q(X).\nq(X) :- p(X).\n');
         assertEqual(nafProgram.findGroup('p', 1).wfsDatalog, false, '\\+/1 remains ordinary negation as failure');
@@ -7756,7 +7804,23 @@ undefined_case :- tnot(win(c)).
 `;
         assertEqual(run(source, { goal: 'true_case' }).stdout, 'true_case.\n', 'win(a) is true because b is false');
         assertEqual(run(source, { goal: 'false_case' }).stdout, '', 'tnot(win(a)) fails for a true atom');
-        assertEqual(run(source, { goal: 'undefined_case' }).stdout, 'undefined_case.\n', 'tnot of an undefined WFS atom is a conditional success');
+        assertEqual(run(source, { goal: 'undefined_case' }).stdout, '', 'tnot of an undefined WFS atom is not a successful answer');
+      },
+    },
+    {
+      name: 'undefined WFS goals do not run continuations or print CLI answers',
+      run: () => {
+        const source = `
+:- use_module(library(tabling)).
+:- table(a/0).
+:- table(b/0).
+a :- tnot(b).
+b :- tnot(a).
+`;
+        const result = run(source, { goal: 'a, write(true), nl; halt' });
+        assertEqual(result.stdout, '', 'undefined first branch neither writes nor produces a ground answer');
+        assertEqual(result.haltCode, 0, 'fallback halt branch runs');
+        assertEqual(result.stats.wfs_undefined_answers, 1, 'undefined atom remains observable in statistics');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -465,6 +465,11 @@ for `[a,b|Tail]`; with `double_quotes(codes)`, it denotes `[97,98|Tail]`. The
 splice is not available when `double_quotes(atom)` is active, and
 `--iso-strict` rejects it as an implementation-specific syntax extension.
 
+Normal-mode integer constants may use one underscore between adjacent digits,
+as in `1_000` or `0xCA_FE`. Layout, including comments and newlines, may follow
+the underscore before the next digit. Separators do not apply to floating-point
+fractions or exponents, and `--iso-strict` rejects them.
+
 Plain atom constants begin with a lowercase ASCII letter. Variables begin with
 an uppercase letter or underscore. The bare `_` is anonymous and every
 occurrence is fresh. `_Name` is a named variable; repeated occurrences refer to
@@ -1139,8 +1144,9 @@ win(X) :- move(X, Y), tnot(win(Y)).
 ```
 
 Here neither `win(a)` nor `win(b)` is unconditionally established; both belong
-to the undefined part of the well-founded model. EyeProlog exposes undefined
-WFS answers as conditional successes, including inside finite collectors.
+to the undefined part of the well-founded model. EyeProlog retains that state
+internally but does not expose undefined atoms as successful query answers or
+run the remaining goals of a conjunction through them.
 Direct calls to `tnot/1` must be ground. In WFS rules, variables occurring in
 the head or a negated literal must be range-restricted by positive body
 literals. Ordinary `\+/1` is unchanged, and strict ISO mode does not provide
@@ -1659,8 +1665,8 @@ The reported counters include completed goal lists, calls to the goal solver
 and single-goal solver, unification attempts, maximum depth and goal-list size,
 deterministic built-in successes and failures, and table fixed-point rounds.
 WFS execution additionally reports `wfs_fixpoint_rounds` and
-`wfs_undefined_answers`. The latter counts undefined-answer observations made
-while producing query results; it is an execution statistic, not a declaration
+`wfs_undefined_answers`. The latter counts undefined atoms encountered while
+resolving query goals; it is an execution statistic, not a declaration
 that those atoms are true. All statistics describe work performed, not logical
 truth. Compare counters only across equivalent queries and the same
 implementation version.
@@ -5648,8 +5654,10 @@ lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
 ISO double-quoted-list notation. Integers, decimals, scientific notation,
 binary/octal/hexadecimal integers, and character-code constants are accepted.
-Normal mode additionally accepts the Trealla-compatible `"text"||Tail`
-right-splice for double-quoted `chars`/`codes` lists; strict ISO mode does not.
+Normal mode additionally accepts digit-separated integer constants such as
+`1_000` and `0xCA_FE`, with optional layout after the underscore, and the
+Trealla-compatible `"text"||Tail` right-splice for double-quoted `chars`/`codes`
+lists; strict ISO mode accepts neither syntax extension.
 
 The processor character set is shared by normal and `--iso-strict` modes because
 Part 1 makes it implementation defined rather than an extension boundary.
@@ -6190,7 +6198,7 @@ quoted_atom("ab").           % quoted_atom(ab)
 - **`sub_atom(+Atom,?Before,?Length,?After,?SubAtom)`** — Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers.
 - **`atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)`** — Convert between an atom and a proper list of one-character atoms or character codes. Both profiles use EyeProlog's Unicode scalar PCS/codes; surrogates and values above U+10FFFF are rejected. At least one side must be instantiated.
 - **`char_code(?Character,?Code)`** — Converts one character atom and its collating/code value. Both profiles accept Unicode scalar codes and reject surrogates/out-of-range values.
-- **`number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)`** — Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*.
+- **`number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)`** — Convert finite numbers to canonical text or parse a proper character/code list using number and negative-number syntax, including radix integers, character-code constants, and leading layout. Normal mode also accepts digit separators in integer input; strict mode retains the ISO syntax. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*.
 
 Conversions accept partial output lists when the atomic input is known, but
 constructing an atom or number requires a complete proper list with no unbound