eyeprolog 1.3.46 → 1.3.48

package/package.json

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

package/src/iso-arithmetic.js

@@ -20,10 +20,57 @@ function evaluate(term, env, options = {}) {
     throw new PrologError('type_error(evaluable)', compound('/', [atom(term.name), numberTerm(0)]));
   }
   if (term.type !== COMPOUND) throw new PrologError('type_error(evaluable)', term);
-  const args = term.args.map((arg) => evaluate(arg, env, options));
-  return evaluateOperation(term, args);
+
+  let args;
+  if (options.isoStrict === true) {
+    // ISO 7.9.2(b) gives a direct variable argument precedence over the other
+    // expression errors of the same compound expression. Check the direct
+    // arguments before selecting an implementation-dependent evaluation order.
+    const operands = term.args.map((arg) => deref(arg, env));
+    if (operands.some((arg) => arg.type === VAR)) throw new PrologError('instantiation_error');
+    args = operands.map((arg) => evaluateOperand(term, arg, env, options));
+  } else {
+    // Preserve the normal EyeProlog profile's established left-to-right
+    // evaluator and diagnostics; the stricter prescribed errors belong to
+    // the explicit ISO profile.
+    args = term.args.map((arg) => evaluate(arg, env, options));
+  }
+  return evaluateOperation(term, args, options);
+}
+
+function evaluatesAtomDirectly(term, options) {
+  return term.type === ATOM && (term.name === 'pi' || (term.name === 'e' && options.isoStrict !== true));
 }
-function evaluateOperation(term, args) {
+
+function directOperandType(term) {
+  const name = term.name;
+  const arity = term.arity;
+  if ((arity === 1 && name === '\\') ||
+      (arity === 2 && ['>>', '<<', '/\\', '\\/', 'xor'].includes(name))) return 'integer';
+
+  if ((arity === 1 && ['+', '-', 'abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
+    'float_integer_part', 'float_fractional_part', 'sin', 'cos', 'atan', 'asin', 'acos', 'tan',
+    'exp', 'log', 'sqrt'].includes(name)) ||
+      (arity === 2 && ['+', '-', '*', '/', '//', 'div', 'mod', 'rem', '**', '^', 'max', 'min', 'atan2'].includes(name))) {
+    return 'number';
+  }
+  return null;
+}
+
+function evaluateOperand(parent, operand, env, options) {
+  // The arithmetic-functor error clauses use the offending operand as the
+  // culprit when an atomic operand is not numeric (e.g. +(foo,77),
+  // truncate(foo), and the bitwise families).  A nested compound still goes
+  // through ordinary expression evaluation so an unknown nested F/N retains
+  // type_error(evaluable,F/N).
+  if (operand.type === ATOM && !evaluatesAtomDirectly(operand, options)) {
+    const expected = directOperandType(parent);
+    if (expected) throw new PrologError(`type_error(${expected})`, operand);
+  }
+  return evaluate(operand, env, options);
+}
+
+function evaluateOperation(term, args, options = {}) {
   const name = term.name;
   const arity = term.arity;
   if (arity === 1 && (name === '+' || name === '-')) {
@@ -38,6 +85,12 @@ function evaluateOperation(term, args) {
   if (arity === 1 && ['abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
     'float_integer_part', 'float_fractional_part',
     'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt'].includes(name)) {
+    // The four float-to-integer rounding functors have only F->I operators
+    // (9.1.1/9.1.6). Corrigendum 1/2 therefore requires type_error(float,...)
+    // when their evaluated argument has integer type.
+    if (options.isoStrict === true && ['truncate', 'round', 'ceiling', 'floor'].includes(name) && args[0].integer) {
+      throw new PrologError('type_error(float)', numericTerm(args[0]));
+    }
     const a = Number(args[0].value);
     if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };
     if (name === 'sign' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -1n : args[0].value > 0n ? 1n : 0n };
@@ -105,6 +158,11 @@ function evaluateOperation(term, args) {
     if (x === 0 && y === 0) throw new PrologError('evaluation_error(undefined)');
     value = Math.atan2(x, y);
   }
+  else if ((name === '**' || name === '^') && x === 0 && y < 0) {
+    // 9.3.1.3(d) and Cor.2 9.3.10.3(d): zero to a negative power is
+    // undefined, not floating-point overflow.
+    throw new PrologError('evaluation_error(undefined)');
+  }
   else if (name === '+') value = x + y;
   else if (name === '-') value = x - y;
   else if (name === '*') value = x * y;
@@ -152,6 +210,22 @@ export function compareArithmeticValues(left, right) {
   if (right.integer) return -compareIntegerToFloat(b, a);
   return a < b ? -1 : a > b ? 1 : 0;
 }
+
+function compareStrictIsoArithmeticValues(left, right) {
+  if (left.integer === right.integer) return compareArithmeticValues(left, right);
+
+  // ISO/IEC 13211-1:1995 8.7 specifies mixed arithmetic comparisons by
+  // floatI->F conversion of the integer operand.  That conversion can round
+  // an otherwise exact integer and can itself overflow.  Normal EyeProlog
+  // deliberately keeps its later exact cross-type comparison extension; the
+  // strict profile follows the Part 1 operation table.
+  const leftValue = left.integer ? Number(left.value) : left.value;
+  const rightValue = right.integer ? Number(right.value) : right.value;
+  if (!Number.isFinite(leftValue) || !Number.isFinite(rightValue)) {
+    throw new PrologError('evaluation_error(float_overflow)');
+  }
+  return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
 export function* isBuiltin({ solver, goal, env }) {
   const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env, { isoStrict: solver?.isoStrict === true }));
   const next = env.clone();
@@ -162,7 +236,9 @@ export function arithmeticComparison(test) {
     const options = { isoStrict: solver?.isoStrict === true };
     const left = evaluateArithmetic(goal.args[0], env, options);
     const right = evaluateArithmetic(goal.args[1], env, options);
-    const cmp = compareArithmeticValues(left, right);
+    const cmp = solver?.isoStrict === true
+      ? compareStrictIsoArithmeticValues(left, right)
+      : compareArithmeticValues(left, right);
     if (test(cmp)) yield env;
   };
 }

package/src/iso.js

@@ -415,11 +415,19 @@ function* functorBuiltin({ goal, env }) {
 }
 
 function* argBuiltin({ goal, env }) {
-  const index = requireInteger(goal.args[0], env);
+  const indexTerm = deref(goal.args[0], env);
   const term = deref(goal.args[1], env);
+  // ISO 8.5.2.3 prescribes both instantiation checks before either type
+  // check.  In particular arg(a, X, _) is an instantiation error because
+  // the second argument is still a variable.
+  if (indexTerm.type === VAR) throw new PrologError('instantiation_error');
   if (term.type === VAR) throw new PrologError('instantiation_error');
+  if (indexTerm.type !== NUMBER || !isDecimalInteger(indexTerm.name)) {
+    throw new PrologError('type_error(integer)', indexTerm);
+  }
   if (term.type !== COMPOUND) throw new PrologError('type_error(compound)', term);
-  if (index < 0n) throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[0], env));
+  const index = BigInt(indexTerm.name);
+  if (index < 0n) throw new PrologError('domain_error(not_less_than_zero)', indexTerm);
   if (index === 0n || index > BigInt(term.arity)) return;
   const next = env.clone();
   if (unify(goal.args[2], term.args[Number(index) - 1], next)) yield next;
@@ -815,8 +823,14 @@ function conversionCharacter(term, env, current = false, solver = null) {
   return value;
 }
 function* charConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env, false, solver);
-  const output = conversionCharacter(goal.args[1], env, false, solver);
+  // ISO 8.14.5.3 checks both arguments for instantiation before testing
+  // either character representation.
+  const inputTerm = deref(goal.args[0], env);
+  const outputTerm = deref(goal.args[1], env);
+  if (inputTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (outputTerm.type === VAR) throw new PrologError('instantiation_error');
+  const input = conversionCharacter(inputTerm, env, false, solver);
+  const output = conversionCharacter(outputTerm, env, false, solver);
   if (input.name === output.name) solver.charConversions.delete(input.name);
   else solver.charConversions.set(input.name, output.name);
   yield env;
@@ -1689,11 +1703,16 @@ function* atomLengthBuiltin({ goal, env }) {
 }
 
 function* atomConcatBuiltin({ goal, env }) {
-  const first = resolvedOrVariable(goal.args[0], env, ATOM);
-  const second = resolvedOrVariable(goal.args[1], env, ATOM);
-  const whole = resolvedOrVariable(goal.args[2], env, ATOM);
+  const first = deref(goal.args[0], env);
+  const second = deref(goal.args[1], env);
+  const whole = deref(goal.args[2], env);
+  // ISO 8.16.2.3 puts the two under-instantiation modes ahead of all atom
+  // type diagnostics.
   if (first.type === VAR && whole.type === VAR) throw new PrologError('instantiation_error');
   if (second.type === VAR && whole.type === VAR) throw new PrologError('instantiation_error');
+  if (first.type !== VAR && first.type !== ATOM) throw new PrologError('type_error(atom)', first);
+  if (second.type !== VAR && second.type !== ATOM) throw new PrologError('type_error(atom)', second);
+  if (whole.type !== VAR && whole.type !== ATOM) throw new PrologError('type_error(atom)', whole);
 
   const candidates = [];
   if (whole.type === ATOM && first.type === VAR && second.type === VAR) {
@@ -1713,23 +1732,33 @@ function* atomConcatBuiltin({ goal, env }) {
   }
 }
 
-function optionalNonNegativeInteger(term, env) {
+function optionalInteger(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) return null;
   if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
-  const integer = BigInt(value.name);
-  if (integer < 0n) throw new PrologError('domain_error(not_less_than_zero)', value);
-  return integer;
+  return BigInt(value.name);
 }
 
 function* subAtomBuiltin({ goal, env }) {
   const source = deref(goal.args[0], env);
   if (source.type === VAR) throw new PrologError('instantiation_error');
   if (source.type !== ATOM) throw new PrologError('type_error(atom)', source);
-  const sub = resolvedOrVariable(goal.args[4], env, ATOM);
-  const before = optionalNonNegativeInteger(goal.args[1], env);
-  const length = optionalNonNegativeInteger(goal.args[2], env);
-  const after = optionalNonNegativeInteger(goal.args[3], env);
+  const sub = deref(goal.args[4], env);
+  if (sub.type !== VAR && sub.type !== ATOM) throw new PrologError('type_error(atom)', sub);
+  // ISO 8.16.3.3 prescribes all type checks before the non-negative domain
+  // checks, in Before/Length/After order.
+  const before = optionalInteger(goal.args[1], env);
+  const length = optionalInteger(goal.args[2], env);
+  const after = optionalInteger(goal.args[3], env);
+  if (before != null && before < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[1], env));
+  }
+  if (length != null && length < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[2], env));
+  }
+  if (after != null && after < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[3], env));
+  }
   const chars = characters(source.name);
   for (let start = 0; start <= chars.length; start++) {
     if (before != null && before !== BigInt(start)) continue;
@@ -1770,9 +1799,14 @@ function validCharacterCode(value, solver = null) {
 }
 
 function listToAtomInput(list, env, kind, solver = null) {
+  const whole = deref(list, env);
   const { items, tail } = listElements(list, env);
-  if (tail.type === VAR || items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
-  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', tail);
+  // Corrigendum 2 distinguishes a partial list from an improper one: only
+  // the former precedes the complete-list type check. Variables in a proper
+  // list prefix are checked after that list-shape diagnostic.
+  if (tail.type === VAR) throw new PrologError('instantiation_error');
+  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', whole);
+  if (items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
   if (kind === 'chars') {
     const invalid = items.find((item) => !oneChar(item));
     if (invalid) throw new PrologError('type_error(character)', invalid);
@@ -1968,7 +2002,14 @@ function numberListText(list, env, kind, valueIsBound, solver = null) {
   const whole = deref(list, env);
   const { items, tail } = listElements(list, env);
   const proper = tail.type === ATOM && tail.name === '[]';
+  // Corrigendum 2 orders conversion-mode instantiation errors specially:
+  // a partial list is diagnosed before its fixed prefix, while an improper
+  // non-list is diagnosed before a variable element in that prefix.
+  if (!valueIsBound && tail.type === VAR) throw new PrologError('instantiation_error');
   if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
+  if (!valueIsBound && items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
 
   const invalid = items.find((item) => item.type !== VAR &&
     (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item, solver)));
@@ -1981,7 +2022,6 @@ function numberListText(list, env, kind, valueIsBound, solver = null) {
   }
 
   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
@@ -2228,7 +2268,11 @@ function* callBuiltin({ solver, goal, env }) {
 function* callClosureBuiltin({ solver, goal, env }) {
   const closure = callable(goal.args[0], env);
   const existing = closure.type === COMPOUND ? closure.args : [];
-  const invoked = compound(closure.name, [...existing, ...goal.args.slice(1)]);
+  const extra = goal.args.slice(1);
+  if (existing.length + extra.length > ISO_MAX_ARITY) {
+    throw new PrologError('representation_error(max_arity)');
+  }
+  const invoked = compound(closure.name, [...existing, ...extra]);
   if (closure.module != null) invoked.module = closure.module;
   const child = solver.cloneForInnerGoal();
   try {

package/test/conformance/ISO-COMPLIANCE.md

@@ -36,12 +36,12 @@ error-ordering alternative to an individual executable assertion.
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access; focused strict checks now cover `current_predicate/1`, `clause/2`, `asserta/1`, `assertz/1`, `retract/1`, Corrigendum 2 `retractall/1`, and `abolish/1` errors plus empty-procedure lifetime. The remaining clause-conversion shall-by-shall mapping is still open. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. |
-| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
+| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now also pins direct-variable precedence, arithmetic operand type errors, float-only rounding conversions, zero-to-negative-power undefined errors, and the Part 1 mixed integer/float comparison conversion rule. Exceptional-value/error-precedence mapping remains to be exhaustively enumerated. |
 | 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The audit now also covers write-mode creation/truncation, append creation, repositioned overwrite, flushing, EOF actions, close/current-stream handling, strict stream-position terms, stream-property validation, stream-term requirements, and text-vs-binary permission errors. The full option/mode cross-product is still being mapped. |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. Strict mode excludes the EyeProlog `occurs_check` extension. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Exact ISO 8.14.1-8.14.4 error precedence is covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors, Corrigendum 2 `keysort/2` errors, and arithmetic culprit reporting. A complete one-row-per-prescribed-error ordering map remains open. |
-| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, and closed 8.17 flags. The remaining mode/error matrix is not yet one-row-per-standard-row. |
-| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, and reports unknown zero-arity evaluables with the required `F/0` culprit shape. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
+| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Exact ISO 8.14.1-8.14.4 error precedence is covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors, Corrigendum 2 `keysort/2` errors, atomic-conversion list-shape precedence, `arg/3`, `atom_concat/3`, `sub_atom/5`, `char_conversion/2`, and arithmetic culprit/precedence reporting. A complete one-row-per-prescribed-error ordering map remains open. |
+| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, closed 8.17 flags, and additional prescribed precedence for `arg/3`, `atom_concat/3`, `sub_atom/5`, number/atom list conversions, and `char_conversion/2`. The remaining mode/error matrix is not yet one-row-per-standard-row. |
+| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, enforces the Part 1 numeric/integer operand errors and float-only rounding modes, and uses the Part 1 integer-to-float conversion rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison extension. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -110,6 +110,31 @@ EyeProlog-only evaluable atom `e`, while the Corrigendum arithmetic additions
 remain available. These corrections narrow the remaining `audit` rows but do
 not by themselves close the full shall-by-shall/error-order exit criteria.
 
+The next Corrigendum 2 pass closes two smaller prescribed-error gaps.
+`call/2..8` now raises `representation_error(max_arity)` when appending its
+extra arguments would make the resulting goal exceed the declared `max_arity`,
+rather than falling through to a procedure-existence error. Reverse
+`atom_chars/2` and `atom_codes/2` now report the complete improper `List`
+argument as the culprit of `type_error(list, List)`, as required by the
+Corrigendum 2 replacement error clauses. Dedicated strict-core regressions pin
+both behaviors.
+
+
+The following Part 1 pass tightens more of the still-open prescribed-error and
+arithmetic matrix. `arg/3`, `atom_concat/3`, `sub_atom/5`, `number_chars/2`,
+`number_codes/2`, and `char_conversion/2` now follow the standard ordering when
+multiple error conditions are simultaneously present. Corrigendum 2 partial
+versus improper list distinctions are applied consistently to atomic and
+number conversion. Clause 9 strict evaluation now gives the prescribed
+number/integer operand diagnostics, checks direct-variable instantiation first,
+enforces the float-only input modes of `floor/1`, `truncate/1`, `round/1`, and
+`ceiling/1`, and reports zero raised to a negative power as undefined. Finally,
+strict mixed integer/float arithmetic comparisons perform the Part 1
+integer-to-float conversion (including `float_overflow`); normal EyeProlog keeps
+its exact cross-type comparison as an extension. Dedicated strict regressions
+cover these distinctions without changing the normal-profile arithmetic error
+contract.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does

package/test/conformance/ISO-MATRIX.md

@@ -11,14 +11,14 @@ compliance audit and the remaining work before a full conformance claim.
 | Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, strict ASCII PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
-| 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `functor/3` / `=../2` error-order plus max-arity checks |
+| 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `arg/3`, `functor/3` / `=../2` error-order plus max-arity checks |
 | 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors |
 | 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses`, plus strict clause/database error and all-solutions precedence checks |
 | 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases, strict 8.14.1-8.14.4 option/error-order tests, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, and open/close semantics |
-| 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin` |
-| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived error cases |
-| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, and the strict complete-flag audit in `run-iso-strict.mjs` |
-| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension and zero-arity unknown-evaluable error checks |
+| 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus strict Corrigendum 2 resulting-goal `max_arity` error coverage |
+| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived error cases, strict Corrigendum 2 partial/improper-list precedence for atom/number conversions, and prescribed `atom_concat/3` / `sub_atom/5` ordering checks |
+| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, strict `char_conversion/2` precedence, and the complete strict flag audit in `run-iso-strict.mjs` |
+| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and negative-power errors, float-only rounding modes, and Part 1 mixed integer/float comparison conversion |
 | Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
 | Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 

package/test/run-iso-strict.mjs

@@ -243,6 +243,60 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'type_error(atom)', 'operator type');
   });
 
+  reporter.test('follows remaining Part 1 built-in error precedence', () => {
+    const cases = [
+      ['arg(a,X,_)', 'instantiation_error', 'arg/3 second-argument instantiation before index type'],
+      ['atom_concat(1,X,Y)', 'instantiation_error', 'atom_concat/3 second/whole under-instantiation before first type'],
+      ['atom_concat(X,1,Y)', 'instantiation_error', 'atom_concat/3 first/whole under-instantiation before second type'],
+      ['sub_atom(a,-1,bad,_,_)', 'type_error(integer)', 'sub_atom/5 integer type before non-negative domain'],
+      ['number_chars(N,[1|T])', 'instantiation_error', 'number_chars/2 partial list before element type'],
+      ['number_chars(N,[X,1])', 'instantiation_error', 'number_chars/2 variable element before later element type'],
+      ['number_codes(N,[foo|T])', 'instantiation_error', 'number_codes/2 partial list before element type'],
+      ['number_codes(N,[X,foo])', 'instantiation_error', 'number_codes/2 variable element before later element type'],
+      ['atom_chars(A,[X|foo])', 'type_error(list)', 'atom_chars/2 improper list before prefix variable'],
+      ['atom_codes(A,[X|foo])', 'type_error(list)', 'atom_codes/2 improper list before prefix variable'],
+      ['char_conversion(foo,X)', 'instantiation_error', 'char_conversion/2 output instantiation before input representation'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+  });
+
+  reporter.test('follows Part 1 arithmetic type and exceptional errors', () => {
+    const cases = [
+      ["X is '+'(foo,77)", 'type_error(number)', 'simple arithmetic atomic operand'],
+      ['X is mod(foo,77)', 'type_error(number)', 'integer arithmetic non-number operand'],
+      ['X is mod(7.5,2)', 'type_error(integer)', 'integer arithmetic numeric type'],
+      ['X is truncate(foo)', 'type_error(number)', 'rounding non-number operand'],
+      ['X is sin(foo)', 'type_error(number)', 'transcendental non-number operand'],
+      ['X is foo+Y', 'instantiation_error', 'direct variable before another operand error'],
+      ['X is floor(7)', 'type_error(float)', 'floor integer operand'],
+      ['X is truncate(7)', 'type_error(float)', 'truncate integer operand'],
+      ['X is round(7)', 'type_error(float)', 'round integer operand'],
+      ['X is ceiling(7)', 'type_error(float)', 'ceiling integer operand'],
+      ['X is 0 ** -1', 'evaluation_error(undefined)', 'power zero negative exponent'],
+      ['X is 0.0 ^ -1', 'evaluation_error(undefined)', 'Corrigendum 2 power zero negative exponent'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+  });
+
+  reporter.test('uses the Part 1 mixed arithmetic comparison operations', () => {
+    // 8.7 converts the integer operand to float in mixed comparisons.
+    equal(run('', { isoStrict: true, goal: '18014398509481985 =:= 18014398509481984.0' }).stats.completed_goal_lists,
+      1, 'mixed equality after float conversion');
+    equal(run('', { isoStrict: true, goal: '\\+ (18014398509481985 > 18014398509481984.0)' }).stats.completed_goal_lists,
+      1, 'mixed ordering after float conversion');
+    const huge = `1${'0'.repeat(400)}`;
+    equal(capture(() => run('', { isoStrict: true, goal: `${huge} > 1.0` })).formal,
+      'evaluation_error(float_overflow)', 'mixed integer-to-float overflow');
+
+    // The normal profile retains EyeProlog's exact cross-type extension.
+    equal(run('', { goal: '9007199254740993 > 9007199254740992.0' }).stats.completed_goal_lists,
+      1, 'normal exact mixed ordering extension');
+  });
+
   reporter.test('follows ISO term-construction error types and precedence', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'functor(_,foo(a),1)' })).formal,
       'type_error(atomic)', 'functor compound name');
@@ -252,6 +306,22 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'type_error(list)', '=../2 fixed non-list');
   });
 
+  reporter.test('enforces Corrigendum 2 call/N max-arity errors', () => {
+    equal(capture(() => run('', {
+      isoStrict: true,
+      goal: 'functor(T,f,65535), call(T,x)',
+    })).formal, 'representation_error(max_arity)', 'call/2 resulting arity');
+  });
+
+  reporter.test('reports the complete List culprit for Corrigendum 2 atomic conversions', () => {
+    for (const goal of ['atom_chars(A,[a|foo])', 'atom_codes(A,[97|foo])']) {
+      const error = capture(() => run('', { isoStrict: true, goal }));
+      equal(error.formal, 'type_error(list)', `${goal} formal`);
+      includes(error.message, '[', `${goal} complete list culprit`);
+      if (error.message.endsWith(', foo)')) throw new Error(`${goal}: reported only the improper tail`);
+    }
+  });
+
   reporter.test('follows ISO clause/2 private-procedure error precedence', () => {
     equal(capture(() => run('p.\n', { isoStrict: true, goal: 'clause(atom(_),4)' })).formal,
       'permission_error(access, private_procedure)', 'private procedure before body callability');