eyeling 1.34.2 → 1.34.4

package/examples/eyelang/output/path-discovery.pl

@@ -1,3 +1,3 @@
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Heraklion International Nikos Kazantzakis Airport -> Václav Havel Airport Prague").
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Diagoras Airport -> Václav Havel Airport Prague").
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Palma De Mallorca Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Heraklion International Nikos Kazantzakis Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Diagoras Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Palma De Mallorca Airport -> Václav Havel Airport Prague").

package/examples/eyelang/output/reusable-builtins.pl

@@ -0,0 +1,5 @@
+report(normalized_name, "ada lovelace").
+report(unique_tags, ["logic", "math", "programming"]).
+report(tag_label, "logic / math / programming").
+report(score_summary, summary(42, 21, 6.4807406984078604)).
+report(window, [13, 21]).

package/examples/eyelang/output/term-tools.pl

@@ -0,0 +1,6 @@
+report(shape, shape(edge, 3)).
+report(second_argument, b).
+report(parts, parts(edge, [a, b, 3])).
+report(rebuilt, edge(c, d, 5)).
+report(rendered, "edge(a, [b, c])").
+report(all_weights_positive, yes).

package/examples/eyelang/path-discovery.pl

@@ -1,20 +1,35 @@
 % Generic path discovery over the air-routes graph.
-% Change or add route_request(FromLabel, ToLabel, MaxStopOvers) to answer other routes.
+% Add route_request(FromLabel, ToLabel, MaxStopOvers) facts to answer other routes.
+% MaxStopOvers is converted to a leg limit, and the recursive search keeps a
+% visited list so it works without the removed finite-search helper builtins.
+
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(airroute, 2).
+materialize(airroute, 4).
 
 % Program structure: facts set up the scenario, and rules derive the materialized conclusions.
 route_request("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2).
 
 % Derivation rules: each rule below contributes one logical step toward the displayed results.
-airroute(discovered, RouteText) :-
-  route_request(From, To, MaxStopOvers),
-  airport(Source, From),
-  airport(Destination, To),
+airroute(FromLabel, ToLabel, MaxStopOvers, RouteText) :-
+  route_request(FromLabel, ToLabel, MaxStopOvers),
+  route_between(FromLabel, ToLabel, MaxStopOvers, RouteText).
+
+route_between(FromLabel, ToLabel, MaxStopOvers, RouteText) :-
+  airport(Source, FromLabel),
+  airport(Destination, ToLabel),
   add(MaxStopOvers, 1, MaxLegs),
-  bounded_path(flight, Source, Destination, MaxLegs, Path),
+  simple_path(Source, Destination, MaxLegs, [Source], ReversePath),
+  reverse(ReversePath, Path),
   route_text(Path, RouteText).
 
+simple_path(Node, Node, _RemainingLegs, Visited, Visited).
+simple_path(Node, Goal, RemainingLegs, Visited, Path) :-
+  gt(RemainingLegs, 0),
+  flight(Node, Next),
+  not_member(Next, Visited),
+  sub(RemainingLegs, 1, NextRemainingLegs),
+  simple_path(Next, Goal, NextRemainingLegs, [Next|Visited], Path).
+
 route_text([Node], Text) :-
   airport(Node, Text).
 route_text([Node|Rest], Text) :-

package/examples/eyelang/reusable-builtins.pl

@@ -0,0 +1,32 @@
+% Reusable builtin tour: normalize text, summarize lists, and compute numeric values.
+materialize(report, 2).
+
+name_raw("  Ada Lovelace  ").
+tag_csv("logic,math,logic,programming").
+scores([8, 13, 21]).
+
+report(normalized_name, Name) :-
+  name_raw(Raw),
+  trim(Raw, Trimmed),
+  lowercase(Trimmed, Name).
+
+report(unique_tags, Tags) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags).
+
+report(tag_label, Label) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags),
+  join(Tags, " / ", Label).
+
+report(score_summary, summary(Total, Peak, RootTotal)) :-
+  scores(Scores),
+  sum_list(Scores, Total),
+  max_list(Scores, Peak),
+  sqrt(Total, RootTotal).
+
+report(window, Slice) :-
+  scores(Scores),
+  slice(1, 2, Scores, Slice).

package/examples/eyelang/term-tools.pl

@@ -0,0 +1,23 @@
+% Term tools: inspect and build structured terms, then validate all facts with forall/2.
+materialize(report, 2).
+
+edge(a, b, 3).
+edge(b, c, 4).
+
+report(shape, shape(Name, Arity)) :-
+  functor(edge(a, b, 3), Name, Arity).
+
+report(second_argument, Node) :-
+  arg(2, edge(a, b, 3), Node).
+
+report(parts, parts(Name, Args)) :-
+  compound_name_arguments(edge(a, b, 3), Name, Args).
+
+report(rebuilt, Term) :-
+  compound_name_arguments(Term, edge, [c, d, 5]).
+
+report(rendered, Text) :-
+  term_string(edge(a, [b, c]), Text).
+
+report(all_weights_positive, yes) :-
+  forall(edge(_From, _To, Weight), gt(Weight, 0)).

package/lib/eyelang/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', '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,7 +63,7 @@ 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();
@@ -61,6 +71,7 @@ function binary(name) {
       else if (name === 'mul') out = (a * b).toString();
       else if (name === 'div') { if (b === 0n) return; out = (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,6 +88,8 @@ function binary(name) {
       else if (name === 'div') { if (b === 0) return; value = a / b; }
       else if (name === 'pow') value = Math.pow(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/lib/eyelang/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/lib/eyelang/builtins/lists.js

@@ -1,23 +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('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];
@@ -62,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();
@@ -74,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;
@@ -81,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;
@@ -132,6 +211,59 @@ function* lengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(items.length), next)) yield next;
 }
 
+function* sumList({ goal, env }) {
+  const items = properListItems(goal.args[0], 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 }) {
   const items = properListItems(goal.args[0], env);
@@ -142,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/lib/eyelang/builtins/registry.js

@@ -7,9 +7,7 @@ import { listBuiltins } from './lists.js';
 import { aggregationBuiltins } from './aggregation.js';
 import { contextBuiltins } from './context.js';
 import { controlBuiltins } from './control.js';
-import { searchBuiltins } from './search.js';
-import { numberTheoryBuiltins } from './number-theory.js';
-import { matrixBuiltins } from './matrix.js';
+import { termBuiltins } from './terms.js';
 
 export class BuiltinRegistry {
   constructor() {
@@ -36,7 +34,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, termBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/lib/eyelang/builtins/strings.js

@@ -1,16 +1,76 @@
 // String builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { compound, 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) {
     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 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);
@@ -53,6 +113,99 @@ function* matchCaptures({ goal, env }) {
   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)) {
@@ -68,3 +221,14 @@ function contextFromGroups(groups) {
 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;
+}