eyelang 1.6.0 → 1.7.0

package/src/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+import('./cli.js').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+  console.error(`eyelang: ${error && error.message ? error.message : String(error)}`);
+  process.exit(1);
+});

package/src/builtins/arithmetic.js

@@ -2,8 +2,8 @@
 // The code keeps BigInt paths where possible so large eyelang integers remain exact.
 import { compareIntegerText, deref, isDecimalInteger, lexicalValue, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.js';
 
-const unaryNames = ['neg', 'abs', 'sin', 'cos', 'asin', 'acos', 'rounded', 'log'];
-const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'max', 'min', 'pow'];
+const unaryNames = ['neg', 'abs', 'sin', 'cos', 'tan', 'asin', 'acos', 'sqrt', 'floor', 'ceiling', 'trunc', 'rounded', 'exp', 'log'];
+const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'min', 'max', 'pow', 'atan2'];
 const compareNames = ['lt', 'gt', 'le', 'ge'];
 
 export const arithmeticBuiltins = {
@@ -22,9 +22,11 @@ function unary(name) {
     const text = lexicalValue(goal.args[0], env);
     if (text == null) return;
     let out = null;
-    if ((name === 'neg' || name === 'abs') && isDecimalInteger(text)) {
+    if ((name === 'neg' || name === 'abs' || name === 'floor' || name === 'ceiling' || name === 'trunc' || name === 'rounded') && isDecimalInteger(text)) {
       const value = BigInt(text);
-      out = (name === 'neg' ? -value : value < 0n ? -value : value).toString();
+      if (name === 'neg') out = (-value).toString();
+      else if (name === 'abs') out = (value < 0n ? -value : value).toString();
+      else out = value.toString();
     } else {
       const input = parseFiniteNumber(text);
       if (input == null) return;
@@ -33,14 +35,22 @@ function unary(name) {
       else if (name === 'abs') value = Math.abs(input);
       else if (name === 'sin') value = Math.sin(input);
       else if (name === 'cos') value = Math.cos(input);
+      else if (name === 'tan') value = Math.tan(input);
       else if (name === 'asin') value = Math.asin(input);
       else if (name === 'acos') value = Math.acos(input);
+      else if (name === 'sqrt') { if (input < 0) return; value = Math.sqrt(input); }
+      else if (name === 'floor') value = Math.floor(input);
+      else if (name === 'ceiling') value = Math.ceil(input);
+      else if (name === 'trunc') value = Math.trunc(input);
       else if (name === 'rounded') value = Math.round(input);
+      else if (name === 'exp') value = Math.exp(input);
       else if (name === 'log') {
         if (input <= 0) return;
         value = logCompat(input);
       }
-      out = name === 'rounded' ? String(Math.trunc(value)) : numberTextFromDouble(value);
+      out = (name === 'floor' || name === 'ceiling' || name === 'trunc' || name === 'rounded')
+        ? String(Math.trunc(value))
+        : numberTextFromDouble(value);
     }
     const next = env.clone();
     if (out != null && unify(goal.args[1], numberTerm(out), next)) yield next;
@@ -53,15 +63,15 @@ function binary(name) {
     const rightText = lexicalValue(goal.args[1], env);
     if (leftText == null || rightText == null) return;
     let out = null;
-    if (isDecimalInteger(leftText) && isDecimalInteger(rightText) && name !== 'mod') {
+    if (isDecimalInteger(leftText) && isDecimalInteger(rightText) && name !== 'mod' && name !== 'atan2') {
       const a = BigInt(leftText);
       const b = BigInt(rightText);
       if (name === 'add') out = (a + b).toString();
       else if (name === 'sub') out = (a - b).toString();
       else if (name === 'mul') out = (a * b).toString();
       else if (name === 'div') { if (b === 0n) return; out = (a / b).toString(); }
-      else if (name === 'max') out = (a >= b ? a : b).toString();
       else if (name === 'min') out = (a <= b ? a : b).toString();
+      else if (name === 'max') out = (a >= b ? a : b).toString();
       else if (name === 'pow') { if (b < 0n) return; out = (a ** b).toString(); }
     } else if (name === 'mod') {
       if (!isDecimalInteger(leftText) || !isDecimalInteger(rightText)) return;
@@ -77,8 +87,9 @@ function binary(name) {
       else if (name === 'mul') value = a * b;
       else if (name === 'div') { if (b === 0) return; value = a / b; }
       else if (name === 'pow') value = Math.pow(a, b);
-      else if (name === 'max') value = Math.max(a, b);
       else if (name === 'min') value = Math.min(a, b);
+      else if (name === 'max') value = Math.max(a, b);
+      else if (name === 'atan2') value = Math.atan2(a, b);
       out = numberTextFromDouble(value);
     }
     const next = env.clone();

package/src/builtins/context.js

@@ -0,0 +1,42 @@
+// Context builtins that treat comma conjunctions as first-class data terms.
+// These are used by examples that construct or inspect rule bodies programmatically.
+import { atom, deref, isConjunction, listFromItems, unify } from '../term.js';
+
+export const contextBuiltins = {
+  register(registry) {
+    registry.add('holds', 2, holdsTerm);
+    registry.add('holds', 3, holdsParts);
+  }
+};
+
+function* emitContextTerm(context, term, env) {
+  context = deref(context, env);
+  if (isConjunction(context)) {
+    yield* emitContextTerm(context.args[0], term, env);
+    yield* emitContextTerm(context.args[1], term, env);
+    return;
+  }
+  const next = env.clone();
+  if (unify(term, context, next)) yield next;
+}
+
+function* emitContextParts(context, name, args, env) {
+  context = deref(context, env);
+  if (isConjunction(context)) {
+    yield* emitContextParts(context.args[0], name, args, env);
+    yield* emitContextParts(context.args[1], name, args, env);
+    return;
+  }
+  if (context.type !== 'atom' && context.type !== 'compound') return;
+  const next = env.clone();
+  const argList = context.type === 'compound' ? listFromItems(context.args) : listFromItems([]);
+  if (unify(name, atom(context.name), next) && unify(args, argList, next)) yield next;
+}
+
+function* holdsTerm({ goal, env }) {
+  yield* emitContextTerm(goal.args[0], goal.args[1], env);
+}
+
+function* holdsParts({ goal, env }) {
+  yield* emitContextParts(goal.args[0], goal.args[1], goal.args[2], env);
+}

package/src/builtins/control.js

@@ -3,6 +3,7 @@ export const controlBuiltins = {
   register(registry) {
     registry.add('not', 1, notBuiltin);
     registry.add('once', 1, onceBuiltin);
+    registry.add('forall', 2, forallBuiltin);
   }
 };
 
@@ -20,3 +21,14 @@ function* onceBuiltin({ solver, goal, env }) {
     break;
   }
 }
+
+function* forallBuiltin({ solver, goal, env }) {
+  const generator = solver.cloneForInnerGoal(10000000);
+  for (const answerEnv of generator.solve([goal.args[0]], env.clone(), 0)) {
+    const checker = solver.cloneForInnerGoal(1);
+    let ok = false;
+    for (const _ of checker.solve([goal.args[1]], answerEnv.clone(), 0)) { ok = true; break; }
+    if (!ok) return;
+  }
+  yield env;
+}

package/src/builtins/lists.js

@@ -1,24 +1,62 @@
-// List builtins for proper lists, selection, membership, sorting, and indexing.
+// List builtins for proper lists, selection, membership, sorting, indexing, slicing, and summaries.
 // Several predicates support both checking and generation, so the argument modes are handled explicitly.
-import { compareTerms, copyResolved, deref, isCons, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
+import {
+  compareTerms,
+  copyResolved,
+  deref,
+  isDecimalInteger,
+  isCons,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  numberTextFromDouble,
+  parseFiniteNumber,
+  properListItems,
+  unify,
+} from '../term.js';
 
 export const listBuiltins = {
   register(registry) {
     registry.add('append', 3, append);
     registry.add('nth0', 3, nth0);
     registry.add('set_nth0', 4, setNth0, { deterministic: true });
-    registry.add('rest', 2, rest, { deterministic: true });
+    registry.add('head', 2, head, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('rest', 2, rest, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('last', 2, last, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('take', 3, take, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('drop', 3, drop, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('slice', 4, slice, { deterministic: true, fallbackWhenNotReady: true, ready: sliceReady });
     registry.add('member', 2, member);
     registry.add('select', 3, select);
     registry.add('not_member', 2, notMember, { deterministic: true });
     registry.add('reverse', 2, reverse, { deterministic: true });
     registry.add('length', 2, lengthBuiltin, { deterministic: true });
-    registry.add('is_list', 1, isList, { deterministic: true });
+    registry.add('sum_list', 2, sumList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('min_list', 2, minList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('max_list', 2, maxList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('list_to_set', 2, listToSet, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
     registry.add('sort', 2, sortBuiltin, { deterministic: true });
   }
 };
 
 
+
+function firstConsReady(goal, env) {
+  return isCons(deref(goal.args[0], env));
+}
+
+function firstProperListReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null;
+}
+
+function countAndListReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && properListItems(goal.args[1], env) !== null;
+}
+
+function sliceReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
 function listFromItemsExcept(items, skip) {
   const copy = new Array(items.length - 1);
   for (let i = 0, j = 0; i < items.length; i++) if (i !== skip) copy[j++] = items[i];
@@ -63,10 +101,8 @@ function* nth0({ goal, env }) {
 }
 
 function* setNth0({ goal, env }) {
-  const indexText = lexicalValue(goal.args[0], env);
-  if (!/^-?\d+$/.test(indexText ?? '')) return;
-  const index = Number(indexText);
-  if (!Number.isSafeInteger(index) || index < 0) return;
+  const index = safeIndex(goal.args[0], env);
+  if (index == null) return;
   const items = properListItems(goal.args[1], env);
   if (!items || index >= items.length) return;
   const out = items.slice();
@@ -75,6 +111,13 @@ function* setNth0({ goal, env }) {
   if (unify(goal.args[3], listFromItems(out), next)) yield next;
 }
 
+function* head({ goal, env }) {
+  const list = deref(goal.args[0], env);
+  if (!isCons(list)) return;
+  const next = env.clone();
+  if (unify(goal.args[1], list.args[0], next)) yield next;
+}
+
 function* rest({ goal, env }) {
   const list = deref(goal.args[0], env);
   if (!isCons(list)) return;
@@ -82,6 +125,41 @@ function* rest({ goal, env }) {
   if (unify(goal.args[1], list.args[1], next)) yield next;
 }
 
+function* last({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  const next = env.clone();
+  if (unify(goal.args[1], items[items.length - 1], next)) yield next;
+}
+
+function* take({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, 0, count), next)) yield next;
+}
+
+function* drop({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, count, items.length), next)) yield next;
+}
+
+function* slice({ goal, env }) {
+  const start = safeIndex(goal.args[0], env);
+  const count = safeIndex(goal.args[1], env);
+  if (start == null || count == null) return;
+  const items = properListItems(goal.args[2], env);
+  if (!items || start + count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], listFromItems(items, start, start + count), next)) yield next;
+}
+
 function* member({ goal, env }) {
   const items = properListItems(goal.args[1], env);
   if (!items) return;
@@ -133,9 +211,58 @@ function* lengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(items.length), next)) yield next;
 }
 
-function* isList({ goal, env }) {
+function* sumList({ goal, env }) {
   const items = properListItems(goal.args[0], env);
-  if (items) yield env;
+  if (!items) return;
+  let intSum = 0n;
+  let floatMode = false;
+  let floatSum = 0;
+  for (const item of items) {
+    const text = lexicalValue(item, env);
+    if (text == null) return;
+    if (!floatMode && isDecimalInteger(text)) intSum += BigInt(text);
+    else {
+      const value = parseFiniteNumber(text);
+      if (value == null) return;
+      if (!floatMode) { floatSum = Number(intSum); floatMode = true; }
+      floatSum += value;
+    }
+  }
+  const out = floatMode ? numberTextFromDouble(floatSum) : intSum.toString();
+  const next = env.clone();
+  if (unify(goal.args[1], numberTerm(out), next)) yield next;
+}
+
+function* minList({ goal, env }) {
+  yield* minMaxList(goal, env, true);
+}
+
+function* maxList({ goal, env }) {
+  yield* minMaxList(goal, env, false);
+}
+
+function* minMaxList(goal, env, wantMin) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  let best = copyResolved(items[0], env);
+  for (let i = 1; i < items.length; i++) {
+    const item = copyResolved(items[i], env);
+    const cmp = compareTerms(item, best);
+    if ((wantMin && cmp < 0) || (!wantMin && cmp > 0)) best = item;
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], best, next)) yield next;
+}
+
+function* listToSet({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  const unique = [];
+  for (const item of items.map((entry) => copyResolved(entry, env))) {
+    if (!unique.some((seen) => compareTerms(seen, item) === 0)) unique.push(item);
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems(unique), next)) yield next;
 }
 
 function* sortBuiltin({ goal, env }) {
@@ -147,3 +274,10 @@ function* sortBuiltin({ goal, env }) {
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(unique), next)) yield next;
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}

package/src/builtins/registry.js

@@ -5,15 +5,9 @@ import { coreBuiltins } from './core.js';
 import { stringBuiltins } from './strings.js';
 import { listBuiltins } from './lists.js';
 import { aggregationBuiltins } from './aggregation.js';
-import { formulaBuiltins } from './formula.js';
+import { contextBuiltins } from './context.js';
 import { controlBuiltins } from './control.js';
-import { sudokuBuiltins } from './sudoku.js';
-import { portfolioBuiltins } from './portfolio.js';
-import { searchBuiltins } from './search.js';
-import { numberTheoryBuiltins } from './number-theory.js';
-import { matrixBuiltins } from './matrix.js';
-import { alphameticBuiltins } from './alphametic.js';
-import { n3Builtins } from './n3.js';
+import { termBuiltins } from './terms.js';
 
 export class BuiltinRegistry {
   constructor() {
@@ -40,7 +34,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, formulaBuiltins, controlBuiltins, sudokuBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins, n3Builtins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, termBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/src/builtins/strings.js

@@ -1,24 +1,82 @@
-// String and atom conversion builtins.
+// String builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { atom, lexicalValue, stringTerm, unify } from '../term.js';
+import {
+  atom,
+  compound,
+  deref,
+  isDecimalInteger,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  parseFiniteNumber,
+  properListItems,
+  stringTerm,
+  termToString,
+  unify,
+} from '../term.js';
 
 export const stringBuiltins = {
   register(registry) {
-    for (const name of ['atom_concat', 'str_concat']) registry.add(name, 3, concat(name), { deterministic: true });
-    for (const name of ['contains', 'not_contains', 'matches', 'not_matches']) registry.add(name, 2, contains(name), { deterministic: true });
+    registry.add('str_concat', 3, concat, { deterministic: true });
+    for (const name of ['contains', 'matches', 'not_matches']) registry.add(name, 2, contains(name), { deterministic: true });
+    registry.add('matches', 3, matchCaptures, { deterministic: true });
+    registry.add('split', 3, split, { deterministic: true, fallbackWhenNotReady: true, ready: firstTwoLexicalReady });
+    registry.add('join', 3, join, { deterministic: true, fallbackWhenNotReady: true, ready: listAndSecondLexicalReady });
+    registry.add('substring', 4, substring, { deterministic: true, fallbackWhenNotReady: true, ready: substringReady });
+    registry.add('replace', 4, replace, { deterministic: true, fallbackWhenNotReady: true, ready: firstThreeLexicalReady });
+    registry.add('lowercase', 2, caseFold('lower'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('uppercase', 2, caseFold('upper'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('trim', 2, trim, { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('number_string', 2, numberString, { deterministic: true, fallbackWhenNotReady: true, ready: numberStringReady });
+    registry.add('atom_string', 2, atomString, { deterministic: true, fallbackWhenNotReady: true, ready: atomStringReady });
+    registry.add('term_string', 2, termString, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
   }
 };
 
 
-function concat(name) {
-  return function* ({ goal, env }) {
-    const left = lexicalValue(goal.args[0], env);
-    const right = lexicalValue(goal.args[1], env);
-    if (left == null || right == null) return;
-    const result = name === 'str_concat' ? stringTerm(left + right) : atom(left + right);
-    const next = env.clone();
-    if (unify(goal.args[2], result, next)) yield next;
-  };
+
+function firstLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null;
+}
+
+function firstTwoLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function firstThreeLexicalReady(goal, env) {
+  return firstTwoLexicalReady(goal, env) && lexicalValue(goal.args[2], env) !== null;
+}
+
+function listAndSecondLexicalReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function substringReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && safeIndex(goal.args[2], env) !== null;
+}
+
+function numberStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'number' || right.type === 'string' || right.type === 'atom';
+}
+
+function atomStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'atom' || right.type === 'string' || right.type === 'atom' || right.type === 'number';
+}
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
+function* concat({ goal, env }) {
+  const left = lexicalValue(goal.args[0], env);
+  const right = lexicalValue(goal.args[1], env);
+  if (left == null || right == null) return;
+  const next = env.clone();
+  if (unify(goal.args[2], stringTerm(left + right), next)) yield next;
 }
 
 function contains(name) {
@@ -29,13 +87,148 @@ function contains(name) {
     const has = haystack.includes(needle);
     const matches = simpleAlternationMatch(haystack, needle);
     const pass = (name === 'contains' && has) ||
-      (name === 'not_contains' && !has) ||
       (name === 'matches' && matches) ||
       (name === 'not_matches' && !matches);
     if (pass) yield env;
   };
 }
 
+function* matchCaptures({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const pattern = lexicalValue(goal.args[1], env);
+  if (text == null || pattern == null) return;
+
+  let match;
+  try {
+    match = new RegExp(pattern).exec(text);
+  } catch (_) {
+    return;
+  }
+  if (!match?.groups) return;
+
+  const context = contextFromGroups(match.groups);
+  if (context == null) return;
+
+  const next = env.clone();
+  if (unify(goal.args[2], context, next)) yield next;
+}
+
+function* split({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (text == null || separator == null) return;
+  const parts = text.split(separator).map(stringTerm);
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(parts), next)) yield next;
+}
+
+function* join({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (!items || separator == null) return;
+  const strings = [];
+  for (const item of items) {
+    const value = lexicalValue(item, env);
+    if (value == null) return;
+    strings.push(value);
+  }
+  const next = env.clone();
+  if (unify(goal.args[2], stringTerm(strings.join(separator)), next)) yield next;
+}
+
+function* substring({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const start = safeIndex(goal.args[1], env);
+  const count = safeIndex(goal.args[2], env);
+  if (text == null || start == null || count == null || start + count > text.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(text.slice(start, start + count)), next)) yield next;
+}
+
+function* replace({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const search = lexicalValue(goal.args[1], env);
+  const replacement = lexicalValue(goal.args[2], env);
+  if (text == null || search == null || replacement == null) return;
+  const out = search === '' ? text : text.split(search).join(replacement);
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(out), next)) yield next;
+}
+
+function caseFold(direction) {
+  return function* ({ goal, env }) {
+    const text = lexicalValue(goal.args[0], env);
+    if (text == null) return;
+    const next = env.clone();
+    const out = direction === 'lower' ? text.toLowerCase() : text.toUpperCase();
+    if (unify(goal.args[1], stringTerm(out), next)) yield next;
+  };
+}
+
+function* trim({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  if (text == null) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(text.trim()), next)) yield next;
+}
+
+function* numberString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'number') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom') {
+    if (!numericText(right.name)) return;
+    if (unify(goal.args[0], numberTerm(right.name), next)) yield next;
+  }
+}
+
+function* atomString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'atom') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom' || right.type === 'number') {
+    if (unify(goal.args[0], atom(right.name), next)) yield next;
+  }
+}
+
+function* termString({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(termToString(term, env, true)), next)) yield next;
+}
+
+function contextFromGroups(groups) {
+  const terms = [];
+  for (const [name, value] of Object.entries(groups)) {
+    if (value !== undefined) terms.push(compound(name, [stringTerm(value)]));
+  }
+  if (terms.length === 0) return null;
+
+  let context = terms[terms.length - 1];
+  for (let i = terms.length - 2; i >= 0; i--) context = compound(',', [terms[i], context]);
+  return context;
+}
+
 function simpleAlternationMatch(haystack, pattern) {
   return pattern.split('|').some((part) => part === '' || haystack.includes(part));
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}
+
+function numericText(text) {
+  return isDecimalInteger(text) || parseFiniteNumber(text) != null;
+}