eyeprolog 1.1.11 → 1.1.13

package/README.md

@@ -91,12 +91,14 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-EyeProlog also adds 46 public library predicates to its 129-entry ISO registry.
-**All 46 are ordinary Prolog clauses** in `src/lib/eyeprolog.pl`,
-`src/lib/lists.pl`, and `src/lib/prologue.pl`. They are ISO/IEC 13211-2 modules,
+EyeProlog also adds 57 public library predicate indicators to its 129-entry ISO
+profile. **56 are implemented entirely as ordinary Prolog clauses** in
+`src/lib/eyeprolog.pl`, `src/lib/lists.pl`, and `src/lib/prologue.pl`; the
+`call_nth/2` module clause uses one private host adapter to number solutions.
+They are ISO/IEC 13211-2 modules,
 loaded explicitly with `use_module(library(eyeprolog))`,
-`use_module(library(lists))`, or `use_module(library(prologue))`. None requires
-host support. Portable text predicates use ISO atoms or character lists.
+`use_module(library(lists))`, or `use_module(library(prologue))`. Portable text
+predicates use ISO atoms or character lists.
 
 ## Development
 

package/package.json

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

package/src/iso.js

@@ -5,7 +5,7 @@ import {
   isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble,
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
-import { createParserOperatorState, parseClauses } from './parser.js';
+import { createParserOperatorState, parseClauses, parseGoalText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 
@@ -164,6 +164,15 @@ export const isoBuiltins = {
   }
 };
 
+// call_nth/2 is a Prologue library predicate with control behavior that cannot
+// be expressed portably as ordinary Prolog clauses.  Keep the public wrapper
+// in library(prologue) and expose only this private adapter to the host registry.
+export const eyePrologLibraryBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
+  },
+};
+
 function* unification({ goal, env }) {
   const next = env.clone();
   if (unify(goal.args[0], goal.args[1], next)) yield next;
@@ -1397,12 +1406,129 @@ function* charCodeBuiltin({ goal, env }) {
   } else if (unify(goal.args[0], atom(String.fromCodePoint(Number(code.name))), next)) yield next;
 }
 
+function skipNumberLayout(text, start) {
+  let position = start;
+  while (true) {
+    while (position < text.length && /[\u0009-\u000d\u0020]/.test(text[position])) {
+      position++;
+    }
+    if (text[position] === '%') {
+      const newline = text.indexOf('\n', position + 1);
+      if (newline < 0) return text.length;
+      position = newline + 1;
+      continue;
+    }
+    if (text.startsWith('/*', position)) {
+      const end = text.indexOf('*/', position + 2);
+      if (end < 0) return text.length;
+      position = end + 2;
+      continue;
+    }
+    return position;
+  }
+}
+
+function quotedNumberSign(text, start) {
+  if (text[start] !== "'") return null;
+  let position = start + 1;
+  let value = '';
+  while (position < text.length) {
+    let character = text[position++];
+    if (character === "'") {
+      if (text[position] === "'") {
+        position++;
+        value += "'";
+        continue;
+      }
+      return { value, position };
+    }
+    if (character !== '\\') {
+      value += character;
+      continue;
+    }
+    if (position >= text.length) return null;
+    character = text[position++];
+    if (character === '\n') continue;
+    const controls = { a: '\x07', b: '\b', r: '\r', f: '\f', t: '\t', n: '\n', v: '\v' };
+    if (controls[character] != null) {
+      value += controls[character];
+      continue;
+    }
+    value += character;
+  }
+  return null;
+}
+
 function parseIsoNumber(text) {
-  const trimmed = text.replace(/^[\u0009-\u000d\u0020]+/, '');
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed)) return null;
-  if (/^[+-]?\d+$/.test(trimmed)) return numberTerm(BigInt(trimmed).toString());
-  const value = Number(trimmed);
-  return Number.isFinite(value) ? numberTerm(numberTextFromDouble(value)) : null;
+  // 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;
+  let position = skipNumberLayout(text, 0);
+  let sign = '';
+
+  if (text[position] === '-') {
+    if (/[\u0009-\u000d\u0020]/.test(text[position + 1] ?? '')) {
+      position = skipNumberLayout(text, position + 1);
+      sign = '-';
+    }
+  } else {
+    const quoted = quotedNumberSign(text, position);
+    if (quoted?.value === '-') {
+      position = skipNumberLayout(text, quoted.position);
+      sign = '-';
+    }
+  }
+
+  const numericText = `${sign}${text.slice(position)}`;
+  // 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];
+    if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
+    const finite = Number(value.name);
+    if (!Number.isFinite(finite)) return null;
+    return numberTerm(numberTextFromDouble(finite));
+  } catch (_) {
+    return null;
+  }
+}
+
+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);
+  }
+  const leftValue = Number(left.name);
+  const rightValue = Number(right.name);
+  return Number.isFinite(leftValue) && Number.isFinite(rightValue) && leftValue === rightValue;
+}
+
+function numberListText(list, env, kind, valueIsBound) {
+  const whole = deref(list, env);
+  const { items, tail } = listElements(list, env);
+  const proper = tail.type === ATOM && tail.name === '[]';
+  if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
+
+  const invalid = items.find((item) => item.type !== VAR &&
+    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item)));
+  if (invalid) {
+    if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
+    if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
+      throw new PrologError('type_error(integer)', invalid);
+    }
+    throw new PrologError('representation_error(character_code)');
+  }
+
+  const hasVariable = tail.type === VAR || items.some((item) => item.type === VAR);
+  if (!valueIsBound && hasVariable) throw new PrologError('instantiation_error');
+  if (hasVariable) return null;
+  return items.map((item) => kind === 'chars'
+    ? item.name
+    : String.fromCodePoint(Number(item.name))).join('');
 }
 
 function numberListBuiltin(kind) {
@@ -1411,14 +1537,21 @@ function numberListBuiltin(kind) {
     if (value.type !== VAR && value.type !== NUMBER) throw new PrologError('type_error(number)', value);
     const list = deref(goal.args[1], env);
     if (value.type === VAR && list.type === VAR) throw new PrologError('instantiation_error');
+    const text = numberListText(list, env, kind, value.type === NUMBER);
     const next = env.clone();
     if (value.type === NUMBER) {
+      if (text != null) {
+        const parsed = parseIsoNumber(text);
+        if (parsed == null) throw new PrologError('syntax_error(number)');
+        if (sameNumber(value, parsed)) yield next;
+        return;
+      }
       const items = characters(value.name).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    const parsed = parseIsoNumber(listToAtomInput(list, env, kind));
+    const parsed = parseIsoNumber(text);
     if (parsed == null) throw new PrologError('syntax_error(number)');
     if (unify(goal.args[0], parsed, next)) yield next;
   };
@@ -1564,6 +1697,36 @@ function* callClosureBuiltin({ solver, goal, env }) {
   }
 }
 
+function* callNthBuiltin({ solver, goal, env }) {
+  const requestedTerm = deref(goal.args[1], env);
+  // Zero is the one Nth value that fails before Goal is inspected.
+  if (requestedTerm.type === NUMBER && isDecimalInteger(requestedTerm.name) && BigInt(requestedTerm.name) === 0n) return;
+
+  const invoked = callable(goal.args[0], env);
+  let requested = null;
+  if (requestedTerm.type !== VAR) {
+    if (requestedTerm.type !== NUMBER || !isDecimalInteger(requestedTerm.name)) {
+      throw new PrologError('type_error(integer)', requestedTerm);
+    }
+    requested = BigInt(requestedTerm.name);
+    if (requested < 0n) throw new PrologError('domain_error(not_less_than_zero)', requestedTerm);
+  }
+
+  const child = solver.cloneForInnerGoal();
+  let nth = 0n;
+  try {
+    for (const answerEnv of child.solve([invoked], env, 0)) {
+      nth++;
+      if (requested != null && nth < requested) continue;
+      const next = answerEnv.clone();
+      if (unify(goal.args[1], numberTerm(nth.toString()), next)) yield next;
+      if (requested != null) return;
+    }
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
+
 function* phraseBuiltin({ solver, goal, env }) {
   const grammarBody = deref(goal.args[0], env);
   if (grammarBody.type === VAR) throw new PrologError('instantiation_error');

package/src/lib/eyeprolog.pl

@@ -622,7 +622,21 @@ number_string(Number, Text) :-
 number_string(Number, Text) :-
     var(Number),
     eyeprolog__text_chars(Text, Chars),
-    catch(number_chars(Number, Chars), _, fail).
+    catch(number_chars(Number, Chars), _,
+        catch(( eyeprolog__integer_exponent_chars(Chars, Expanded),
+                number_chars(Number, Expanded)
+              ), _, fail)).
+
+eyeprolog__integer_exponent_chars(Chars, Expanded) :-
+    eyeprolog__split_exponent(Chars, Mantissa, Marker, Exponent),
+    number_chars(Integer, Mantissa),
+    integer(Integer),
+    eyeprolog__append(Mantissa, ['.','0',Marker|Exponent], Expanded).
+
+eyeprolog__split_exponent([e|Exponent], [], e, Exponent).
+eyeprolog__split_exponent(['E'|Exponent], [], 'E', Exponent).
+eyeprolog__split_exponent([C|Chars], [C|Mantissa], Marker, Exponent) :-
+    eyeprolog__split_exponent(Chars, Mantissa, Marker, Exponent).
 
 atom_string(Atom, Text) :-
     atom(Atom),

package/src/lib/prologue.pl

@@ -7,10 +7,36 @@
     between/3,
     select/3,
     succ/2,
-    maplist/2
+    maplist/2,
+    maplist/3,
+    maplist/4,
+    maplist/5,
+    maplist/6,
+    maplist/7,
+    maplist/8,
+    nth0/3,
+    nth0/4,
+    nth1/3,
+    nth1/4,
+    call_nth/2,
+    foldl/4,
+    foldl/5,
+    foldl/6,
+    countall/2
 ]).
 
 :- meta_predicate(maplist(1, '?')).
+:- meta_predicate(maplist(2, '?', '?')).
+:- meta_predicate(maplist(3, '?', '?', '?')).
+:- meta_predicate(maplist(4, '?', '?', '?', '?')).
+:- meta_predicate(maplist(5, '?', '?', '?', '?', '?')).
+:- meta_predicate(maplist(6, '?', '?', '?', '?', '?', '?')).
+:- meta_predicate(maplist(7, '?', '?', '?', '?', '?', '?', '?')).
+:- meta_predicate(call_nth(0, '?')).
+:- meta_predicate(foldl(3, '?', '?', '?')).
+:- meta_predicate(foldl(4, '?', '?', '?', '?')).
+:- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
+:- meta_predicate(countall(0, '?')).
 
 member(X, [X|_]).
 member(X, [_|Xs]) :- member(X, Xs).
@@ -74,6 +100,84 @@ maplist(Closure, [X|Xs]) :-
     call(Closure, X),
     maplist(Closure, Xs).
 
+maplist(_, [], []).
+maplist(Closure, [A|As], [B|Bs]) :-
+    call(Closure, A, B),
+    maplist(Closure, As, Bs).
+
+maplist(_, [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs]) :-
+    call(Closure, A, B, C),
+    maplist(Closure, As, Bs, Cs).
+
+maplist(_, [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds]) :-
+    call(Closure, A, B, C, D),
+    maplist(Closure, As, Bs, Cs, Ds).
+
+maplist(_, [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es]) :-
+    call(Closure, A, B, C, D, E),
+    maplist(Closure, As, Bs, Cs, Ds, Es).
+
+maplist(_, [], [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs]) :-
+    call(Closure, A, B, C, D, E, F),
+    maplist(Closure, As, Bs, Cs, Ds, Es, Fs).
+
+maplist(_, [], [], [], [], [], [], []).
+maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs], [G|Gs]) :-
+    call(Closure, A, B, C, D, E, F, G),
+    maplist(Closure, As, Bs, Cs, Ds, Es, Fs, Gs).
+
+nth0(N, List, Elem) :- nth0(N, List, Elem, _).
+
+nth0(N, List, Elem, Rest) :-
+    prologue__integer_or_variable(N),
+    ( var(N) -> prologue__nth0(N, List, Elem, Rest)
+    ; prologue__not_less_than_zero(N),
+      prologue__nth0(N, List, Elem, Rest)
+    ).
+
+prologue__nth0(0, [Elem|Rest], Elem, Rest).
+prologue__nth0(N, [X|Xs], Elem, [X|Rest]) :-
+    var(N),
+    prologue__nth0(N0, Xs, Elem, Rest),
+    N is N0 + 1.
+prologue__nth0(N, [X|Xs], Elem, [X|Rest]) :-
+    nonvar(N),
+    N > 0,
+    N0 is N - 1,
+    prologue__nth0(N0, Xs, Elem, Rest).
+
+nth1(N, List, Elem) :- nth1(N, List, Elem, _).
+
+nth1(N, List, Elem, Rest) :-
+    N \== 0,
+    nth0(N, [_|List], Elem, [_|Rest]),
+    N \== 0.
+
+call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
+
+foldl(_, [], Acc, Acc).
+foldl(Closure, [A|As], Acc0, Acc) :-
+    call(Closure, A, Acc0, Acc1),
+    foldl(Closure, As, Acc1, Acc).
+
+foldl(_, [], [], Acc, Acc).
+foldl(Closure, [A|As], [B|Bs], Acc0, Acc) :-
+    call(Closure, A, B, Acc0, Acc1),
+    foldl(Closure, As, Bs, Acc1, Acc).
+
+foldl(_, [], [], [], Acc, Acc).
+foldl(Closure, [A|As], [B|Bs], [C|Cs], Acc0, Acc) :-
+    call(Closure, A, B, C, Acc0, Acc1),
+    foldl(Closure, As, Bs, Cs, Acc1, Acc).
+
+countall(Goal, Count) :-
+    findall(1, Goal, Ones),
+    length(Ones, Count).
+
 prologue__integer_or_variable(X) :- var(X), !.
 prologue__integer_or_variable(X) :- prologue__integer(X).
 

package/src/standard-library.js

@@ -2,7 +2,7 @@
 // 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 } from './iso.js';
+import { createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { fs, isNode } from './platform.js';
 
 const moduleFiles = Object.freeze({
@@ -35,21 +35,27 @@ function libraryUrl(filename) {
   return url;
 }
 
-export const eyePrologNativeLibraryIndicators = Object.freeze([]);
+export const eyePrologNativeLibraryIndicators = Object.freeze(['call_nth/2']);
 export const eyePrologPortableLibraryIndicators = Object.freeze([
-  'uuid/3', 'difference/3', 'maplist/2', 'maplist/3', 'lt/2', 'gt/2', 'le/2', 'ge/2',
+  'uuid/3', 'difference/3', 'maplist/2', 'maplist/3', 'maplist/4', 'maplist/5',
+  'maplist/6', 'maplist/7', 'maplist/8', 'lt/2', 'gt/2', 'le/2', 'ge/2',
   'between/3', 'smallest_divisor_from/3', 'random/3', 'matches/3', 'split/3',
   'replace/4', 'lowercase/2', 'uppercase/2', 'trim/2', 'number_string/2',
   'atom_string/2', 'term_string/2', 'append/3', 'string_concat/3', 'contains/2',
   'matches/2', 'join/3', 'substring/4', 'member/2', 'select/3', 'last/2',
-  'nth0/3', 'nth1/3', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
+  'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
   'length/2', 'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
-  'countall/2', 'succ/2', 'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
+  'countall/2', 'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
+  'sumall/3', 'aggregate_min/5', 'aggregate_max/5',
+]);
+export const eyePrologLibraryIndicators = Object.freeze([
+  ...eyePrologPortableLibraryIndicators,
+  ...eyePrologNativeLibraryIndicators,
 ]);
-export const eyePrologLibraryIndicators = Object.freeze([...eyePrologPortableLibraryIndicators]);
 
 export function createEyePrologRegistry() {
   const registry = createDefaultRegistry();
+  eyePrologLibraryBuiltins.register(registry);
   registry.eyePrologLibrary = true;
   return registry;
 }

package/test/fixtures/number_chars_cont_quad.pl

@@ -0,0 +1,235 @@
+% ids refer to https://www.complang.tuwien.ac.at/ulrich/iso-prolog/number_chars_cont
+
+1  ?- number_chars(1.2,"1.2").
+      true.
+
+55 ?- number_chars(1.2,"1.20").
+      true.
+
+2  ?- number_chars(1.0e9,"1.0E9").
+      true.
+
+56 ?- number_chars(1.0e9,"1.0e9").
+      true.
+
+64 ?- number_chars(0.0,"-0.0").
+      true.
+
+3  ?- number_chars(1,"01").
+      true.
+
+65 ?- number_chars(10,"010").
+      true.
+
+66 ?- number_chars(N,"010").
+      N=10.
+
+67 ?- number_chars(N,"08").
+      N=8.
+
+68 ?- number_chars(N,"0b11").
+      N=3.
+
+69 ?- number_chars(N,"0o11").
+      N=9.
+
+70 ?- number_chars(N,"0x11").
+      N=17.
+
+4  ?- number_chars(1,"a").
+      syntax_error(...).
+
+5  ?- number_chars(1,[]).
+      syntax_error(...).
+
+6  ?- number_chars(1,[[]]).
+      type_error(character,[]).
+
+7  ?- number_chars(1,[' ',[]]).
+      type_error(character,[]).
+
+8  ?- number_chars(1,[0]).
+      type_error(character,0).
+
+9  ?- number_chars(1,[_,[]]).
+      type_error(character,[]).
+
+10 ?- number_chars(N,[X]).
+      instantiation_error.
+
+11 ?- number_chars(N,['0'|_]).
+      instantiation_error.
+
+12 ?- number_chars(N,'1').
+      type_error(list,'1').
+
+13 ?- number_chars(N,[a|a]).
+      type_error(list,[a|a]).
+
+14 ?- number_chars(N,[49]).
+      type_error(character,49).
+
+15 ?- number_chars(N,[]).
+      syntax_error(...).
+
+16 ?- number_chars(N,"3 ").
+      syntax_error(...).
+
+17 ?- number_chars(N,"3.").
+      syntax_error(...).
+
+18 ?- number_chars(N," 1").
+      N = 1.
+
+19 ?- number_chars(N,"\n1").
+      N = 1.
+
+20 ?- number_chars(N," 0'a").
+      N = 0'a. N = 97.
+
+58 ?- number_chars(N,"0'").
+      syntax_error(...).
+
+59 ?- number_chars(N,"0'\n").
+      syntax_error(...).
+
+60 ?- number_chars(N,"0'\\n").
+      N=0'\n. N=10.
+
+61 ?- number_chars(N,"0'\\7\\").
+      N=7.
+
+71 ?- number_chars(N,"0'\\7").
+      syntax_error(...).
+
+62 ?- number_chars(N,"0'.").
+      N=0'. . N = 46.
+
+21 ?- number_chars(N,"- 1").
+      N = -1.
+
+54 ?- number_chars(N,"'-'1").
+      N = -1.
+
+22 ?- number_chars(N,"/**/1").
+      N = 1.
+
+23 ?- number_chars(N,"%\n1").
+      N = 1.
+
+57 ?- number_chars(N,"- /**/1").
+      N = -1.
+
+24 ?- number_chars(N,"-/**/1").
+      syntax_error(...).
+
+63 ?- number_chars(N,"'\\\n-' 3").
+      N= -3.
+
+25 ?- number_chars(N,"1e1").
+      syntax_error(...).
+
+26 ?- number_chars(N,"1.0e").
+      syntax_error(...).
+
+27 ?- number_chars(N,"1.0ee").
+      syntax_error(...).
+
+28 ?- number_chars(N,"0x1").
+      N = 1.
+
+29 ?- number_chars(N,"0X1").
+      syntax_error(...).
+
+30 ?- number_chars(N,"1E1").
+      syntax_error(...).
+
+47 ?- number_chars(1,['.'|_]).
+      false.
+
+48 ?- number_chars(N,"+1").
+      syntax_error(...).
+
+49 ?- number_chars(N,"+ 1").
+      syntax_error(...).
+
+50 ?- number_chars(N,"'+'1").
+      syntax_error(...).
+
+
+51 ?- number_chars(N,['11']).
+      type_error(character,'11').
+
+52 ?- number_chars(N,['1.1']).
+      type_error(character,'1.1').
+
+53 ?- number_chars(1+1,"2").
+      type_error(number,1+1).
+
+
+31 ?- number_chars(1,[C]).
+      C = '1'.
+
+32 ?- number_chars(1,[C,D]).
+      false.
+
+
+33 ?- number_chars(1,[C,C]).
+      false.
+
+34 ?- number_chars(0,[C,C]).
+      false.
+
+35 ?- number_chars(10,[C,D]).
+      C = '1', D = '0'.
+
+36 ?- number_chars(100,[C,D]).
+      false.
+
+37 ?- number_chars(N,[X|2]).
+      type_error(list,[_|2])
+   |  instantiation_error.
+
+38 ?- number_chars(N,[1|_]).
+      instantiation_error
+   |  type_error(character,1).
+
+39 ?- number_chars(V,[1|2]).
+      type_error(list,[1|2])
+   |  type_error(character,1).
+
+40 ?- number_chars([],1).
+      type_error(number,[])
+   |  type_error(list,1).
+
+41 ?- number_chars(1,1).
+      type_error(list,1).
+
+42 ?- number_chars(1,[a|2]).
+      type_error(list,[a|2]).
+
+43 ?- number_chars(1,[_|2]).
+      type_error(list,[_|2]).
+
+44 ?- number_chars(1,[[]|_]).
+      type_error(character,[]).
+
+45 ?- number_chars(1,[[]|2]).
+      type_error(character,[])
+   |  type_error(list,[[]|2]).
+
+72 ?- number_chars(V,[1,[],X|2]).
+      type_error(list,[1,[],_A|2])
+   |  type_error(character,1)
+   |  type_error(character,[])
+   |  instantiation_error.
+
+46 ?- L=['1'|L], number_chars(N,L).
+      sto, ... ; ... .
+      ( sto, type_error(list,['1'|...]) % rational trees
+      | sto, false % occurs-check
+      | sto, representation_error(term)
+      | sto, instantiation_error % literal substitutions
+      | sto, resource_error(...)
+      | sto, loops
+      ).

package/test/fixtures/prologue_call_nth_quad.pl

@@ -0,0 +1,32 @@
+?- call_nth(true, Nth).
+   Nth = 1.
+?- call_nth(false, Nth).
+   false.
+?- call_nth(repeat, Nth).
+   Nth = 1
+;  Nth = 2
+;  Nth = 3
+;  Nth = 4
+;  Nth = 5
+;  ... .
+?- call_nth(( N = 1 ; N = 2 ), Nth).
+   N = 1, Nth = 1
+;  N = 2, Nth = 2.
+?- call_nth(true, non_integer).
+   type_error(integer,non_integer).
+?- call_nth(true, 1.0).
+   type_error(integer,1.0).
+?- call_nth(true, 0).
+   false.
+?- call_nth(repeat, 0).
+   false.
+?- call_nth(repeat, -1).
+   domain_error(not_less_than_zero,-1).
+?- call_nth(length(L,N), 3).
+   L = [_A,_B], N = 2.
+?- call_nth(inex, 0).
+   false.
+?- call_nth(1, 0).
+   false.
+?- call_nth(V, 0).
+   false.

package/test/fixtures/prologue_call_nth_quad_runner.pl

@@ -0,0 +1,2 @@
+:- use_module(library(prologue)).
+:- include('prologue_call_nth_quad.pl').

package/test/fixtures/prologue_extended_quad.pl

@@ -0,0 +1,87 @@
+% Finite examples and arity coverage for Prologue p.p.7 through p.p.11.
+
+?- maplist(same2, [a], [a]).
+   true.
+?- maplist(same3, [a], [a], [a]).
+   true.
+?- maplist(same4, [a], [a], [a], [a]).
+   true.
+?- maplist(same5, [a], [a], [a], [a], [a]).
+   true.
+?- maplist(same6, [a], [a], [a], [a], [a], [a]).
+   true.
+?- maplist(same7, [a], [a], [a], [a], [a], [a], [a]).
+   true.
+
+?- nth0(1, [a,b,c], E).
+   E = b.
+?- nth0(N, [a,b,c], E).
+   N = 0, E = a
+;  N = 1, E = b
+;  N = 2, E = c.
+?- nth0(0, [A,B|non_list], E).
+   A = E.
+?- nth0(2, Es, E).
+   Es = [_A,_B,E|_C].
+?- nth0(N, Es, E).
+   N = 0, Es = [E|_A]
+;  N = 1, Es = [_A,E|_B]
+;  N = 2, Es = [_A,_B,E|_C]
+;  N = 3, Es = [_A,_B,_C,E|_D]
+;  ... .
+?- nth0(non_integer, Es, E).
+   type_error(integer, non_integer).
+?- nth0(-1, Es, E).
+   domain_error(not_less_than_zero, -1).
+?- nth0(N, [[]|Es], Es).
+   N = 0, Es = []
+;  sto, loops.
+?- nth0(1, [a,b,c], E, Es).
+   E = b, Es = [a,c].
+?- nth1(0, Es, E).
+   false.
+?- nth1(2, [a,b,c], E, Es).
+   E = b, Es = [a,c].
+
+?- call_nth(N = 1, N).
+   N = 1.
+?- call_nth(N = -1, N).
+   false.
+?- call_nth(repeat, 1+1).
+   type_error(integer, 1+1).
+?- call_nth(inex, 0).
+   existence_error(procedure, _), unexpected.
+?- call_nth(G, non_integer).
+   instantiation_error.
+?- call_nth(1, -1).
+   type_error(callable, 1).
+
+?- foldl(append, [[1,2],[3],[4,5]], [], Xs).
+   Xs = [4,5,3,1,2].
+?- foldl(add2, [1,2], [10,20], 0, S).
+   S = 33.
+?- foldl(add3, [1,2], [10,20], [100,200], 0, S).
+   S = 333.
+
+?- countall((X=1;X=2), N).
+   N = 2.
+?- countall((true;true), N).
+   N = 2.
+?- countall(G, N).
+   instantiation_error.
+?- countall((length(L,5),nth0(_,L,_),nth0(_,L,_)), N).
+   N = 25.
+?- countall(N=1, N).
+   N = 1.
+?- countall(N=non_integer, N).
+   N = 1.
+?- countall(false, 1).
+   false.
+?- countall(false, -1).
+   domain_error(not_less_than_zero, -1).
+?- countall(false, non_integer).
+   type_error(integer, non_integer).
+?- countall(G, -1).
+   instantiation_error.
+?- countall(1, -1).
+   type_error(callable, 1).

package/test/fixtures/prologue_extended_quad_runner.pl

@@ -0,0 +1,13 @@
+:- use_module(library(prologue)).
+
+same2(X, X).
+same3(X, X, X).
+same4(X, X, X, X).
+same5(X, X, X, X, X).
+same6(X, X, X, X, X, X).
+same7(X, X, X, X, X, X, X).
+
+add2(X, Y, S0, S) :- S is S0 + X + Y.
+add3(X, Y, Z, S0, S) :- S is S0 + X + Y + Z.
+
+:- include('prologue_extended_quad.pl').

package/test/run-regression.mjs

@@ -50,7 +50,7 @@ const bin = path.join(packageRoot, 'bin', 'eyeprolog.js');
 const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
 let tmp = null;
 let tmpCounter = 0;
-const libraryCall = /\b(?:uuid|difference|maplist|lt|gt|le|ge|between|smallest_divisor_from|random|matches|split|replace|lowercase|uppercase|trim|number_string|atom_string|term_string|append|string_concat|contains|join|substring|member|select|last|nth0|nth1|set_nth0|take|drop|slice|reverse|length|sum_list|min_list|max_list|list_to_set|countall|sumall|aggregate_min|aggregate_max)\s*\(/;
+const libraryCall = /\b(?:uuid|difference|maplist|foldl|call_nth|lt|gt|le|ge|between|smallest_divisor_from|random|matches|split|replace|lowercase|uppercase|trim|number_string|atom_string|term_string|append|string_concat|contains|join|substring|member|select|last|nth0|nth1|set_nth0|take|drop|slice|reverse|length|sum_list|min_list|max_list|list_to_set|countall|sumall|aggregate_min|aggregate_max)\s*\(/;
 
 function withStandardModules(source) {
   if (!libraryCall.test(source) || source.includes('use_module(library(') || source.includes(':- module(')) return source;
@@ -322,6 +322,20 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 58 run, 58 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads passes the complete vendored number_chars continuation corpus',
+      run: () => {
+        const filename = path.join(testRoot, 'fixtures', 'number_chars_cont_quad.pl');
+        const source = fs.readFileSync(filename, 'utf8');
+        const result = publicApi.runQuads(Program.parseSources([{
+          text: source,
+          filename,
+        }]));
+        assertEqual(result.total, 72, 'quad total');
+        assertEqual(result.passed, 72, 'quad passed');
+        assertEqual(result.stdout, 'quads: 72 run, 72 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads passes the complete vendored Prolog Prologue quad corpus',
       run: () => {
@@ -337,6 +351,36 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 33 run, 33 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads passes the authoritative Prologue call_nth quad corpus',
+      run: () => {
+        const filename = path.join(testRoot, 'fixtures', 'prologue_call_nth_quad_runner.pl');
+        const source = fs.readFileSync(filename, 'utf8');
+        const result = publicApi.runQuads(Program.parseSources([{
+          text: source,
+          filename,
+          baseDir: path.dirname(filename),
+        }]));
+        assertEqual(result.total, 13, 'quad total');
+        assertEqual(result.passed, 13, 'quad passed');
+        assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'runQuads covers the remaining finite Prologue examples and arities',
+      run: () => {
+        const filename = path.join(testRoot, 'fixtures', 'prologue_extended_quad_runner.pl');
+        const source = fs.readFileSync(filename, 'utf8');
+        const result = publicApi.runQuads(Program.parseSources([{
+          text: source,
+          filename,
+          baseDir: path.dirname(filename),
+        }]));
+        assertEqual(result.total, 37, 'quad total');
+        assertEqual(result.passed, 37, 'quad passed');
+        assertEqual(result.stdout, 'quads: 37 run, 37 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: 'runQuads rejects malformed answer substitutions',
       run: () => {
@@ -1348,14 +1392,17 @@ 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, 129, 'EyeProlog registry contains only ISO host definitions');
+        assertEqual(library.defs.size, 130, 'EyeProlog registry contains ISO definitions and one private library adapter');
         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(registeredNativeEyePrologLibraryNames().length, 0, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 46, 'portable Prolog library count');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 0, 'native host library count');
-        assertEqual(eyePrologNativeLibraryIndicators.join(','), '', 'no EyeProlog library predicate requires host support');
-        assertEqual(eyePrologLibraryIndicators.length, 46, 'complete EyeProlog library surface');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 1, 'public native EyeProlog builtin count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 56, 'portable Prolog library count');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 1, 'native host library count');
+        assertEqual(eyePrologNativeLibraryIndicators.join(','), 'call_nth/2', 'control predicate requiring host support');
+        assertEqual(eyePrologLibraryIndicators.length, 57, 'complete EyeProlog library surface');
+        assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
+        assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
+        assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');
         assertEqual(library.get('between', 3), null, 'between/3 remains portable Prolog');
         assertEqual(library.get('smallest_divisor_from', 3), null, 'smallest_divisor_from/3 remains portable Prolog');
         assertEqual(library.get('random', 3), null, 'random/3 remains portable Prolog');

package/the-art-of-eyeprolog.md

@@ -5636,7 +5636,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 Unicode scalar codes. At least one side must be instantiated. |
 | `char_code(?Character,?Code)` | Converts one character atom and one Unicode scalar code. Surrogates and values outside `0..0x10ffff` raise a representation error. |
-| `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list. 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 ISO numeric-token syntax, including radix integers, character-code constants, and leading layout. 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
@@ -5761,22 +5761,25 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **46 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **All 46 are ordinary Prolog clauses**
-across `src/lib/eyeprolog.pl`, `src/lib/lists.pl`, and `src/lib/prologue.pl`; none
-is a native host predicate. The resulting
-normal EyeProlog language surface is therefore **175 public predicate
-indicators**. Internally, the runtime registry contains only the 129 ISO
-definitions; the EyeProlog relations are module source clauses.
+EyeProlog exposes **57 library predicate indicators** in addition to the 129
+indicators in its isolated ISO profile. **56 are implemented entirely as
+ordinary Prolog clauses** across `src/lib/eyeprolog.pl`, `src/lib/lists.pl`, and
+`src/lib/prologue.pl`. The Prologue `call_nth/2` clause delegates its solution
+numbering to one private host adapter. The resulting normal EyeProlog language
+surface is therefore **186 public predicate indicators**. Internally, the
+runtime registry contains the 129 ISO definitions plus that private adapter;
+the remaining EyeProlog relations are module source clauses.
 
 The three Prolog files declare `eyeprolog`, `lists`, and `prologue` with
 `module/2`. A program loads them explicitly with
 `use_module(library(eyeprolog))`, `use_module(library(lists))`, or
 `use_module(library(prologue))`; `use_module/2` can select a smaller import
-list. The last module implements the predicates exercised by the working-draft
-Prologue quad corpus.
-`src/standard-library.js` only registers the module sources for Node and browser
-resolution and never adds clauses implicitly.
+list. The last module implements p.p.1 through p.p.11 of the
+[working-draft Prologue](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue),
+with the published `call_nth/2` quads and finite examples retained as offline
+regressions. `src/standard-library.js` registers the module sources and private
+control adapter for Node and browser resolution, and never adds clauses
+implicitly.
 The isolated ISO-only registry remains
 available through `createDefaultRegistry()` and `getDefaultRegistry()` for
 conformance work and advanced embedders. Module-local predicate identity keeps
@@ -5788,7 +5791,7 @@ private helpers and same-named predicates in different modules separate.
 | --- | --- |
 | `library(lists)` | `maplist/3`, `append/3`, `member/2`, `select/3`, `last/2`, `nth0/3`, `nth1/3`, `reverse/2`, `length/2`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `countall/2` |
 | `library(eyeprolog)` | `uuid/3`, `difference/3`, `lt/2`, `le/2`, `gt/2`, `ge/2`, `between/3`, `smallest_divisor_from/3`, `random/3`, `matches/3`, `split/3`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2`, `string_concat/3`, `contains/2`, `matches/2`, `join/3`, `substring/4`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2` |
+| `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` |
 
 <!-- eyeprolog-library-catalog:end -->
 
@@ -5915,7 +5918,7 @@ eyeprolog --goal 'answer(Kind, Value)' program.pl
 The portable text API uses **ISO atoms or proper lists of one-character atoms**.
 A generated text result defaults to an atom. Double-quoted source text uses the
 ISO representation selected by `double_quotes`; with the default `chars`, it is
-already a proper character list accepted by this API. The 46-predicate portable
+already a proper character list accepted by this API. The 56-predicate portable
 library itself has no STRING or JavaScript dependency.
 
 | Predicate and principal mode | Behavior |