seam-lang 2.0.0

package/src/term.js

@@ -0,0 +1,349 @@
+// Term model, environments, unification, readback, and ordering helpers.
+// This file is intentionally dependency-free because nearly every other module imports it.
+export const VAR = 'var';
+export const ATOM = 'atom';
+export const STRING = 'string';
+export const NUMBER = 'number';
+export const COMPOUND = 'compound';
+
+export class Term {
+  constructor(type, name, args = []) {
+    this.type = type;
+    this.name = String(name ?? '');
+    this.args = args;
+  }
+  get arity() {
+    return this.args.length;
+  }
+}
+
+export const variable = (name) => new Term(VAR, name);
+export const atom = (name) => new Term(ATOM, name);
+export const stringTerm = (value) => new Term(STRING, value);
+export const numberTerm = (value) => new Term(NUMBER, value);
+export const compound = (name, args = []) => args.length === 0 ? atom(name) : new Term(COMPOUND, name, args);
+export const emptyList = () => atom('[]');
+export const cons = (head, tail) => compound('.', [head, tail]);
+
+export class Env {
+  constructor(bindings) {
+    this.bindings = bindings ? new Map(bindings) : new Map();
+  }
+  clone() {
+    return new Env(this.bindings);
+  }
+  has(name) {
+    return this.bindings.has(name);
+  }
+  get(name) {
+    return this.bindings.get(name);
+  }
+  bind(name, term) {
+    this.bindings.set(name, term);
+  }
+}
+
+export function deref(term, env) {
+  // Follow variable bindings until a non-variable term is reached. The seen set
+  // protects readback from accidental cycles in partially constructed terms.
+  let current = term;
+  const seen = new Set();
+  while (current?.type === VAR && env?.has(current.name)) {
+    if (seen.has(current.name)) break;
+    seen.add(current.name);
+    current = env.get(current.name);
+  }
+  return current;
+}
+
+export function isScalar(term) {
+  return term && (term.type === ATOM || term.type === STRING || term.type === NUMBER);
+}
+
+export function isEmptyList(term) {
+  return term?.type === ATOM && term.name === '[]';
+}
+
+export function isCons(term) {
+  return term?.type === COMPOUND && term.name === '.' && term.arity === 2;
+}
+
+export function isConjunction(term) {
+  return term?.type === COMPOUND && term.name === ',' && term.arity === 2;
+}
+
+export function unify(left, right, env) {
+  // Iterative unification avoids deep JavaScript recursion on long lists or
+  // deeply nested compounds. Bindings are written into the supplied Env.
+  const stack = [[left, right]];
+  while (stack.length) {
+    let [a, b] = stack.pop();
+    a = deref(a, env);
+    b = deref(b, env);
+
+    if (a.type === VAR && b.type === VAR && a.name === b.name) continue;
+    if (a.type === VAR) {
+      env.bind(a.name, b);
+      continue;
+    }
+    if (b.type === VAR) {
+      env.bind(b.name, a);
+      continue;
+    }
+
+    if (a.type !== b.type) {
+      if (isScalar(a) && isScalar(b) && a.name === b.name) continue;
+      return false;
+    }
+
+    if (isScalar(a)) {
+      if (a.name !== b.name) return false;
+      continue;
+    }
+
+    if (a.type === COMPOUND) {
+      if (a.name !== b.name || a.arity !== b.arity) return false;
+      for (let i = a.arity - 1; i >= 0; i--) stack.push([a.args[i], b.args[i]]);
+      continue;
+    }
+
+    return false;
+  }
+  return true;
+}
+
+export function cloneTerm(term) {
+  if (term.type === COMPOUND && term.arity === 0) return atom(term.name);
+  return new Term(term.type, term.name, term.args.map(cloneTerm));
+}
+
+export function freshTerm(term, suffix) {
+  if (term.type === VAR) return variable(`${term.name}#${suffix}`);
+  if (term.type === COMPOUND && term.arity === 0) return atom(term.name);
+  return new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix)));
+}
+
+export function copyResolved(term, env) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) return variable(resolved.name);
+  if (resolved.type === COMPOUND && resolved.arity === 0) return atom(resolved.name);
+  return new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
+}
+
+export function termIsGround(term, env = new Env()) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) return false;
+  return resolved.args.every((arg) => termIsGround(arg, env));
+}
+
+const graphicAtomChars = new Set('#$&*+-/<=>@^~\\'.split(''));
+
+function atomNeedsQuotes(name) {
+  if (!name) return true;
+  if (name === '[]') return false;
+  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
+  for (const ch of name) if (!graphicAtomChars.has(ch)) return true;
+  return false;
+}
+
+function quoteAtom(name) {
+  let out = "'";
+  for (const ch of name) {
+    if (ch === "'") out += "''";
+    else if (ch === '\\') out += '\\\\';
+    else if (ch === '\n') out += '\\n';
+    else if (ch === '\t') out += '\\t';
+    else out += ch;
+  }
+  return out + "'";
+}
+
+function writeAtom(name) {
+  return atomNeedsQuotes(name) ? quoteAtom(name) : name;
+}
+
+function legacyVariableToIso(name) {
+  if (name === '?') return '_';
+  const tail = name.slice(1);
+  if (!tail) return '_';
+  if (tail[0] === '_') return tail;
+  return tail[0].toUpperCase() + tail.slice(1);
+}
+
+function writeVariable(name) {
+  name = String(name ?? '');
+  if (/^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/.test(name)) return legacyVariableToIso(name);
+  if (/^(?:_|[A-Z_][A-Za-z0-9_]*)$/.test(name)) return name;
+  const sanitized = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (!sanitized) return '_';
+  return /^[A-Z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+}
+
+function writeString(value, quoteStrings) {
+  if (!quoteStrings) return value;
+  let out = '"';
+  for (const ch of value) {
+    if (ch === '"' || ch === '\\') out += `\\${ch}`;
+    else if (ch === '\n') out += '\\n';
+    else out += ch;
+  }
+  return out + '"';
+}
+
+function writeList(term, env) {
+  const parts = [];
+  let cursor = term;
+  while (true) {
+    cursor = deref(cursor, env);
+    if (isEmptyList(cursor)) return `[${parts.join(', ')}]`;
+    if (!isCons(cursor)) {
+      if (parts.length) return `[${parts.join(', ')} | ${termToString(cursor, env, true)}]`;
+      return `[${termToString(cursor, env, true)}]`;
+    }
+    parts.push(termToString(cursor.args[0], env, true));
+    cursor = cursor.args[1];
+  }
+}
+
+export function termToString(term, env = new Env(), quoteStrings = true) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) return writeVariable(resolved.name);
+  if (isCons(resolved)) return writeList(resolved, env);
+  if (resolved.type === STRING) return writeString(resolved.name, quoteStrings);
+  if (resolved.type === ATOM) return writeAtom(resolved.name);
+  if (resolved.type === NUMBER) return resolved.name;
+  if (resolved.type === COMPOUND && resolved.arity === 0) return writeAtom(resolved.name);
+  if (isConjunction(resolved)) {
+    const parts = [];
+    let cursor = resolved;
+    while (true) {
+      cursor = deref(cursor, env);
+      if (isConjunction(cursor)) {
+        parts.push(termToString(cursor.args[0], env, true));
+        cursor = cursor.args[1];
+      } else {
+        parts.push(termToString(cursor, env, true));
+        break;
+      }
+    }
+    return `(${parts.join(', ')})`;
+  }
+  return `${writeAtom(resolved.name)}(${resolved.args.map((arg) => termToString(arg, env, true)).join(', ')})`;
+}
+
+export function lexicalValue(term, env) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) return null;
+  if (resolved.type === ATOM || resolved.type === STRING || resolved.type === NUMBER) return resolved.name;
+  return termToString(resolved, env, true);
+}
+
+export function properListItems(list, env) {
+  const items = [];
+  let cursor = deref(list, env);
+  while (isCons(cursor)) {
+    items.push(cursor.args[0]);
+    cursor = deref(cursor.args[1], env);
+  }
+  if (!isEmptyList(cursor)) return null;
+  return items;
+}
+
+export function listFromItems(items, start = 0, end = items.length, tail = emptyList()) {
+  let result = tail;
+  for (let i = end - 1; i >= start; i--) result = cons(items[i], result);
+  return result;
+}
+
+export function flattenConjunction(goal) {
+  const out = [];
+  const stack = [goal];
+  while (stack.length) {
+    const current = stack.pop();
+    if (isConjunction(current)) {
+      stack.push(current.args[1], current.args[0]);
+    } else {
+      out.push(current);
+    }
+  }
+  return out;
+}
+
+export function termSignature(term) {
+  return term?.type === COMPOUND ? `${term.name}/${term.arity}` : null;
+}
+
+export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(), reverse = new Map()) {
+  left = deref(left, leftEnv);
+  right = deref(right, rightEnv);
+  if (left.type === VAR || right.type === VAR) {
+    if (left.type !== VAR || right.type !== VAR) return false;
+    if (pairs.has(left.name) || reverse.has(right.name)) {
+      return pairs.get(left.name) === right.name && reverse.get(right.name) === left.name;
+    }
+    pairs.set(left.name, right.name);
+    reverse.set(right.name, left.name);
+    return true;
+  }
+  if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+  for (let i = 0; i < left.arity; i++) {
+    if (!variantTerms(left.args[i], leftEnv, right.args[i], rightEnv, pairs, reverse)) return false;
+  }
+  return true;
+}
+
+export function compareTerms(left, right) {
+  const rank = (term) => ({ [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 })[term.type];
+  left = deref(left, new Env());
+  right = deref(right, new Env());
+  const lr = rank(left);
+  const rr = rank(right);
+  if (lr !== rr) return lr < rr ? -1 : 1;
+  if (left.type === NUMBER) return compareNumberText(left.name, right.name);
+  if (left.type === VAR || left.type === ATOM || left.type === STRING) return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+  if (left.name !== right.name) return left.name < right.name ? -1 : 1;
+  if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;
+  for (let i = 0; i < left.arity; i++) {
+    const cmp = compareTerms(left.args[i], right.args[i]);
+    if (cmp) return cmp;
+  }
+  return 0;
+}
+
+export function isDecimalInteger(text) {
+  return /^-?\d+$/.test(text ?? '');
+}
+
+export function compareIntegerText(left, right) {
+  const a = BigInt(left);
+  const b = BigInt(right);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export function parseFiniteNumber(text) {
+  if (text == null || text === '') return null;
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text)) return null;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : null;
+}
+
+export function numberTextFromDouble(value) {
+  if (!Number.isFinite(value)) return null;
+  if (Object.is(value, -0)) value = 0;
+  let text = Number(value).toPrecision(17);
+  if (text.includes('e') || text.includes('E')) {
+    text = text.replace(/(\.\d*?[1-9])0+(e[+-]?\d+)$/i, '$1$2').replace(/\.0+(e[+-]?\d+)$/i, '$1');
+  } else if (text.includes('.')) {
+    text = text.replace(/0+$/, '').replace(/\.$/, '');
+  }
+  if (!/[.eE]/.test(text)) text += '.0';
+  return text;
+}
+
+export function compareNumberText(left, right) {
+  if (isDecimalInteger(left) && isDecimalInteger(right)) return compareIntegerText(left, right);
+  const a = parseFiniteNumber(left);
+  const b = parseFiniteNumber(right);
+  if (a != null && b != null) return a < b ? -1 : a > b ? 1 : 0;
+  return left < right ? -1 : left > right ? 1 : 0;
+}

package/test/conformance/README.md

@@ -0,0 +1,72 @@
+# Seam conformance suite
+
+This directory contains the executable conformance cases for the Seam language and reference engine. The normative language description is in the [Seam language reference](../../../docs/language-reference.md).
+
+The suite is intentionally file-based so another implementation can run the same programs and compare exact standard output, expected errors, expected warnings, and expected proof output. The conformance corpus is part of the public language contract, not just an implementation smoke test.
+
+All conformance files live under topic directories such as `arithmetic/`, `lists/`, `syntax/`, or `variables/`; new top-level numbered files should not be added. The report uses those directories as coverage categories.
+
+A normal positive case consists of:
+
+- `conformance/cases/<name>.pl` — input program;
+- `conformance/expected/<name>.pl` — exact expected standard output, stored as seam-readable facts.
+
+Expected-error cases consist of:
+
+- `conformance/errors/<name>.pl` — input program that must fail during parsing or execution;
+- `conformance/expected-errors/<name>.txt` — exact expected error message followed by a newline.
+
+Expected-warning cases consist of:
+
+- `conformance/warnings/<name>.pl` — input program run through the CLI with `--warnings`;
+- `conformance/expected-warnings/<name>.pl` — exact expected standard output;
+- `conformance/expected-warnings/<name>.txt` — exact expected standard error.
+
+Expected-proof cases consist of:
+
+- `conformance/proofs/<name>.pl` — input program run through the CLI with `--proof`;
+- `conformance/expected-proofs/<name>.pl` — exact expected standard output, including both answer facts and `why/2` proof facts.
+
+Case names may be nested in category directories such as `arithmetic/`, `strings/`, `lists/`, `terms/`, `atoms/`, `variables/`, `negation/`, or `syntax/`. Expected files mirror the same relative path.
+
+## Running the suite
+
+Run all tests, including conformance, regression, examples, and style checks:
+
+```sh
+npm test
+```
+
+Run only the conformance suite:
+
+```sh
+node test/run-conformance.mjs
+```
+
+Summarize conformance coverage by category:
+
+```sh
+npm run conformance:report
+npm run conformance:report -- conformance-report.md
+```
+
+Run matching conformance cases by passing a filename or directory fragment:
+
+```sh
+node test/run-conformance.mjs reusable
+node test/run-conformance.mjs 092_scalar_string_conversions
+node test/run-conformance.mjs variables/
+node test/run-conformance.mjs error/variables
+```
+
+The runner executes normal materialized programs in-process through the public JavaScript API so small conformance cases avoid measuring Node startup overhead. Warning and proof cases intentionally use the CLI because warning output and `why/2` proof output are host-interface contracts.
+
+## Scope
+
+The conformance corpus is a single seam suite. It covers the standard language described by the language reference: lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification, left-to-right goal-directed proof search, materialized output, read-back printing, standard built-ins, declarations, warnings, errors, proof output, and standard host behavior.
+
+The suite deliberately does not separate `core` and `extension` profiles. Reusable built-ins such as arithmetic, strings, lists, aggregation, context terms, term inspection, and search control are part of the standard seam conformance surface. Implementation-specific built-ins may still exist in downstream hosts, but they should have their own tests outside this corpus unless they are standardized.
+
+## Updating expected output
+
+There is no committed auto-accept mode. To update an expected file, run the matching case with the conformance runner, inspect the result, and replace the corresponding file under `conformance/expected/`, `conformance/expected-errors/`, `conformance/expected-warnings/`, or `conformance/expected-proofs/` deliberately.

package/test/conformance/cases/aggregation/044_findall_user_goal.pl

@@ -0,0 +1,6 @@
+% Reference 9.8: findall/3 collects templates for every solution of a user goal.
+p(b).
+p(a).
+p(b).
+answer(bag, X) :- findall(P, p(P), X).
+materialize(answer, 2).

package/test/conformance/cases/aggregation/044_findall_user_goal.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/aggregation/057_countall_empty_and_nonempty.pl

@@ -0,0 +1,4 @@
+item(a).
+item(b).
+answer(counts, counts(C, Z)) :- countall(item(X), C), countall(missing(X), Z).
+materialize(answer, 2).

package/test/conformance/cases/aggregation/057_countall_empty_and_nonempty.query

@@ -0,0 +1 @@
+(countall(item(X), C), countall(missing(X), Z))

package/test/conformance/cases/aggregation/058_sumall_numeric_template.pl

@@ -0,0 +1,5 @@
+score(a, 4).
+score(b, 5).
+score(c, -2).
+answer(sum, Sum) :- sumall(S, score(_item, S), Sum).
+materialize(answer, 2).

package/test/conformance/cases/aggregation/058_sumall_numeric_template.query

@@ -0,0 +1 @@
+sumall(S, score(_item, S), Sum)

package/test/conformance/cases/aggregation/059_aggregate_min_template.pl

@@ -0,0 +1,5 @@
+score(alpha, 7).
+score(beta, 3).
+score(gamma, 5).
+answer(min, result(Bests, Best)) :- aggregate_min(S, item(Name, S), score(Name, S), Bests, Best).
+materialize(answer, 2).

package/test/conformance/cases/aggregation/059_aggregate_min_template.query

@@ -0,0 +1 @@
+aggregate_min(S, item(Name, S), score(Name, S), Bests, Best)

package/test/conformance/cases/aggregation/060_aggregate_max_compound_key.pl

@@ -0,0 +1,5 @@
+score(alpha, 7).
+score(beta, 7).
+score(gamma, 5).
+answer(max, result(Key, Bestname)) :- aggregate_max([S, Name], Name, score(Name, S), Key, Bestname).
+materialize(answer, 2).

package/test/conformance/cases/aggregation/060_aggregate_max_compound_key.query

@@ -0,0 +1 @@
+aggregate_max([S, Name], Name, score(Name, S), Key, Bestname)

package/test/conformance/cases/aggregation/075_aggregation_edges.pl

@@ -0,0 +1,12 @@
+% Reference 9.1: aggregation handles empty result sets, structured templates, and ordered best answers.
+materialize(answer, 2).
+score(alice, 2).
+score(bob, 1).
+score(cara, 3).
+answer(findall_empty, X) :- findall(V, missing(V), X).
+answer(count_filtered, X) :- countall((score(Name, Score), gt(Score, 1)), X).
+answer(sum_empty, X) :- sumall(V, missing(V), X).
+answer(sum_scores, X) :- sumall(Score, score(Name, Score), X).
+answer(best_min, pair(Key, Value)) :- aggregate_min(Score, Name, score(Name, Score), Key, Value).
+answer(best_max, pair(Key, Value)) :- aggregate_max(Score, Name, score(Name, Score), Key, Value).
+answer(best_empty_rejected, ok) :- not(aggregate_min(Key, Value, missing(Value), Key, Value)).

package/test/conformance/cases/aggregation/098_aggregation_nested_templates.pl

@@ -0,0 +1,11 @@
+% Reference 9.8: aggregation copies resolved structured templates from inner goals.
+materialize(answer, 2).
+score(alice, math, 9).
+score(alice, logic, 7).
+score(bob, math, 5).
+score(bob, logic, 8).
+answer(all_pairs, X) :- findall(result(Name, Subject, Score), score(Name, Subject, Score), X).
+answer(count_high, X) :- countall((score(Name, Subject, Score), ge(Score, 8)), X).
+answer(sum_alice, X) :- sumall(Score, score(alice, Subject, Score), X).
+answer(best_score, pair(Key, Value)) :- aggregate_max(Score, result(Name, Subject), score(Name, Subject, Score), Key, Value).
+answer(lowest_pair, pair(Key, Value)) :- aggregate_min([Score, Name], Subject, score(Name, Subject, Score), Key, Value).

package/test/conformance/cases/aggregation/aggregate_max_no_answers_fails.pl

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(ok) :- not(aggregate_max(Key, Value, missing(Value), BestKey, BestValue)).

package/test/conformance/cases/aggregation/aggregate_min_structured_key.pl

@@ -0,0 +1,5 @@
+materialize(answer, 2).
+candidate(a, 3).
+candidate(b, 1).
+candidate(c, 2).
+answer(Key, Value) :- aggregate_min(score(Score), Name, candidate(Name, Score), Key, Value).

package/test/conformance/cases/aggregation/countall_zero.pl

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(N) :- countall(missing(X), N).

package/test/conformance/cases/aggregation/extra_aggregate_max_iri_key.pl

@@ -0,0 +1,4 @@
+materialize(answer, 3).
+rank('<urn:example:a>', low).
+rank('<urn:example:z>', high).
+answer(aggregate_max_iri_key, Key, Value) :- aggregate_max(K, V, rank(K, V), Key, Value).

package/test/conformance/cases/aggregation/extra_aggregate_min_tie_first.pl

@@ -0,0 +1,5 @@
+materialize(answer, 3).
+score(2, first).
+score(1, keep).
+score(1, also).
+answer(aggregate_min_tie_first, Key, Value) :- aggregate_min(K, V, score(K, V), Key, Value).

package/test/conformance/cases/aggregation/extra_countall_with_filter.pl

@@ -0,0 +1,5 @@
+materialize(answer, 2).
+num(1).
+num(2).
+num(3).
+answer(countall_with_filter, N) :- countall((num(X), gt(X, 1)), N).

package/test/conformance/cases/aggregation/extra_findall_repeated_template.pl

@@ -0,0 +1,4 @@
+materialize(answer, 2).
+item(a).
+item(b).
+answer(findall_repeated_template, Bag) :- findall(pair(X, X), item(X), Bag).

package/test/conformance/cases/aggregation/extra_sumall_float_template.pl

@@ -0,0 +1,4 @@
+materialize(answer, 2).
+val(1.5).
+val(2.25).
+answer(sumall_float_template, Sum) :- sumall(X, val(X), Sum).

package/test/conformance/cases/aggregation/findall_empty_bag.pl

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(Bag) :- findall(X, missing(X), Bag).

package/test/conformance/cases/aggregation/sumall_empty_zero.pl

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(N) :- sumall(X, missing(X), N).

package/test/conformance/cases/arithmetic/024_numeric_literal_readback.pl

@@ -0,0 +1,6 @@
+% Reference 3.3, 11: signed, decimal, and exponent numeric literals retain lexical form.
+raw(negative_decimal, -3.5).
+raw(positive_exp, 6.02e23).
+raw(negative_exp, -1.0e-3).
+answer(K, V) :- raw(K, V).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/029_arithmetic_and_comparison.pl

@@ -0,0 +1,11 @@
+% Reference 9.2, 9.3: arithmetic and comparison built-ins.
+answer(sum, X) :- add(2, 3, X).
+answer(diff, X) :- sub(7, 4, X).
+answer(product, X) :- mul(6, 7, X).
+answer(integer_division, X) :- div(7, 2, X).
+answer(remainder, X) :- mod(7, 2, X).
+answer(power, X) :- pow(2, 8, X).
+answer(minimum, X) :- min(3, 9, X).
+answer(less_than, true) :- lt(3, 9).
+answer(greater_equal, true) :- ge(9, 9).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/029_arithmetic_and_comparison.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/arithmetic/039_numeric_functions.pl

@@ -0,0 +1,9 @@
+% Reference 9.2: scalar arithmetic functions return numeric values.
+answer(neg, X) :- neg(5, X).
+answer(abs, X) :- abs(-5, X).
+answer(rounded, X) :- rounded(2.6, X).
+answer(sin_zero, X) :- sin(0, X).
+answer(cos_zero, X) :- cos(0, X).
+answer(log_one, X) :- log(1, X).
+answer(float_division, X) :- div(7.0, 2.0, X).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/039_numeric_functions.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/arithmetic/040_between_enumeration.pl

@@ -0,0 +1,3 @@
+% Reference 9.5: between/3 enumerates every integer in an inclusive range.
+answer(n, X) :- between(3, 5, X).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/040_between_enumeration.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/arithmetic/041_smallest_divisor.pl

@@ -0,0 +1,3 @@
+% Reference 9.5: smallest_divisor_from/3 finds the first divisor at or above the start.
+answer(divisor, D) :- smallest_divisor_from(21, 2, D).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/041_smallest_divisor.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/arithmetic/054_numeric_and_lexical_comparison.pl

@@ -0,0 +1,5 @@
+% Reference 9.3: comparisons handle numeric and lexical scalar ordering.
+answer(numeric_gt, true) :- gt(10, 2).
+answer(numeric_le, true) :- le(2, 2.0).
+answer(lexical_ge, true) :- ge(beta, alpha).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/054_numeric_and_lexical_comparison.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/conformance/cases/arithmetic/061_date_difference.pl

@@ -0,0 +1,4 @@
+% Reference 9.1: difference/3 computes ISO date durations.
+answer(duration, D) :- difference("2024-03-01", "2020-02-29", D).
+answer(month_borrow, D) :- difference("2024-03-01", "2024-01-31", D).
+materialize(answer, 2).

package/test/conformance/cases/arithmetic/062_reusable_numeric_builtins.pl

@@ -0,0 +1,10 @@
+% Reference 9.1: reusable numeric functions and max/3.
+materialize(answer, 2).
+answer(max, X) :- max(17, 42, X).
+answer(sqrt, X) :- sqrt(81, X).
+answer(floor, X) :- floor(3.9, X).
+answer(ceiling, X) :- ceiling(3.1, X).
+answer(trunc, X) :- trunc(-3.9, X).
+answer(exp, X) :- exp(0, X).
+answer(tan, X) :- tan(0, X).
+answer(atan2, X) :- atan2(0, -1, X).

package/test/conformance/cases/arithmetic/066_numeric_edges.pl

@@ -0,0 +1,14 @@
+% Reference 9.1: reusable numeric functions preserve integer paths and define finite failure modes.
+materialize(answer, 2).
+answer(max_negative, X) :- max(-10, -3, X).
+answer(min_float, X) :- min(2.5, -1.25, X).
+answer(floor_negative, X) :- floor(-3.1, X).
+answer(ceiling_negative, X) :- ceiling(-3.9, X).
+answer(trunc_positive, X) :- trunc(3.9, X).
+answer(sqrt_fraction, X) :- sqrt(2.25, X).
+answer(pow_fraction, X) :- pow(9, 0.5, X).
+answer(sqrt_negative_rejected, ok) :- not(sqrt(-1, X)).
+answer(log_zero_rejected, ok) :- not(log(0, X)).
+answer(div_zero_rejected, ok) :- not(div(1, 0, X)).
+answer(mod_float_rejected, ok) :- not(mod(5.5, 2, X)).
+answer(pow_negative_integer_exponent_rejected, ok) :- not(pow(2, -1, X)).

package/test/conformance/cases/arithmetic/079_big_integer_arithmetic.pl

@@ -0,0 +1,8 @@
+% Reference 9.2: integer arithmetic keeps exact BigInt paths where possible.
+materialize(answer, 2).
+answer(add_big, X) :- add(9007199254740993, 7, X).
+answer(sub_big, X) :- sub(9007199254741000, 7, X).
+answer(mul_big, X) :- mul(123456789, 987654321, X).
+answer(pow_big, X) :- pow(2, 63, X).
+answer(div_big, X) :- div(9223372036854775808, 2, X).
+answer(mod_big, X) :- mod(9223372036854775809, 10, X).