eyelang 0.1.0

package/src/builtins/lists.js

@@ -0,0 +1,283 @@
+// 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,
+  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('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];
+  return listFromItems(copy);
+}
+
+function* append({ goal, env }) {
+  let items = properListItems(goal.args[0], env);
+  if (items) {
+    const result = listFromItems(items, 0, items.length, deref(goal.args[1], env));
+    const next = env.clone();
+    if (unify(goal.args[2], result, next)) yield next;
+    return;
+  }
+  items = properListItems(goal.args[2], env);
+  if (!items) return;
+  for (let split = 0; split <= items.length; split++) {
+    const prefix = listFromItems(items, 0, split);
+    const suffix = listFromItems(items, split, items.length);
+    const next = env.clone();
+    if (unify(goal.args[0], prefix, next) && unify(goal.args[1], suffix, next)) yield next;
+  }
+}
+
+function* nth0({ goal, env }) {
+  const items = properListItems(goal.args[1], env);
+  if (!items) return;
+  const indexText = lexicalValue(goal.args[0], env);
+  if (/^-?\d+$/.test(indexText ?? '')) {
+    const index = Number(indexText);
+    if (Number.isSafeInteger(index) && index >= 0 && index < items.length) {
+      const next = env.clone();
+      if (unify(goal.args[2], items[index], next)) yield next;
+    }
+    return;
+  }
+  if (deref(goal.args[0], env).type !== 'var') return;
+  for (let i = 0; i < items.length; i++) {
+    const next = env.clone();
+    if (unify(goal.args[0], numberTerm(i), next) && unify(goal.args[2], items[i], next)) yield next;
+  }
+}
+
+function* setNth0({ goal, env }) {
+  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();
+  out[index] = goal.args[2];
+  const next = env.clone();
+  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;
+  const next = env.clone();
+  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;
+  for (const item of items) {
+    const next = env.clone();
+    if (unify(goal.args[0], item, next)) yield next;
+  }
+}
+
+function* select({ goal, env }) {
+  const items = properListItems(goal.args[1], env);
+  if (!items) return;
+  for (let i = 0; i < items.length; i++) {
+    const next = env.clone();
+    if (unify(goal.args[0], items[i], next) && unify(goal.args[2], listFromItemsExcept(items, i), next)) yield next;
+  }
+}
+
+function* notMember({ goal, env }) {
+  const items = properListItems(goal.args[1], env);
+  if (!items) return;
+  const value = deref(goal.args[0], env);
+  if (value.type === 'number' || value.type === 'atom' || value.type === 'string') {
+    for (const item of items) {
+      const resolved = deref(item, env);
+      if (resolved.type === value.type && resolved.name === value.name) return;
+    }
+    yield env;
+    return;
+  }
+  for (const item of items) {
+    const attempt = env.clone();
+    if (unify(goal.args[0], item, attempt)) return;
+  }
+  yield env;
+}
+
+function* reverse({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems([...items].reverse()), next)) yield next;
+}
+
+function* lengthBuiltin({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  const next = env.clone();
+  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);
+  if (!items) return;
+  const sorted = items.map((item) => copyResolved(item, env)).sort(compareTerms);
+  const unique = [];
+  for (const item of sorted) if (unique.length === 0 || compareTerms(unique[unique.length - 1], item) !== 0) unique.push(item);
+  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

@@ -0,0 +1,48 @@
+// Registry for builtins and their execution metadata.
+// The solver uses the metadata to know when a builtin is deterministic, mode-ready, or should fall back to user clauses.
+import { arithmeticBuiltins } from './arithmetic.js';
+import { coreBuiltins } from './core.js';
+import { stringBuiltins } from './strings.js';
+import { listBuiltins } from './lists.js';
+import { aggregationBuiltins } from './aggregation.js';
+import { contextBuiltins } from './context.js';
+import { controlBuiltins } from './control.js';
+import { termBuiltins } from './terms.js';
+
+export class BuiltinRegistry {
+  constructor() {
+    this.defs = new Map();
+  }
+  add(name, arity, handler, options = {}) {
+    // ready() describes the argument mode in which the builtin is safe to run;
+    // fallbackWhenNotReady keeps user-defined clauses visible outside that mode.
+    this.defs.set(`${name}/${arity}`, {
+      name,
+      arity,
+      handler,
+      deterministic: options.deterministic ?? false,
+      ready: options.ready ?? null,
+      fallbackWhenNotReady: options.fallbackWhenNotReady ?? false,
+      shouldUse: options.shouldUse ?? null,
+    });
+    return this;
+  }
+  get(name, arity) {
+    return this.defs.get(`${name}/${arity}`) ?? null;
+  }
+}
+
+export function createDefaultRegistry() {
+  const registry = new BuiltinRegistry();
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, termBuiltins]) {
+    mod.register(registry);
+  }
+  return registry;
+}
+
+let defaultRegistry = null;
+
+export function getDefaultRegistry() {
+  if (defaultRegistry == null) defaultRegistry = createDefaultRegistry();
+  return defaultRegistry;
+}

package/src/builtins/strings.js

@@ -0,0 +1,234 @@
+// String builtins.
+// They mostly project from already-ground terms to avoid guessing string domains.
+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);
+  if (left == null || right == null) return;
+  const next = env.clone();
+  if (unify(goal.args[2], stringTerm(left + right), next)) yield next;
+}
+
+function contains(name) {
+  return function* ({ goal, env }) {
+    const haystack = lexicalValue(goal.args[0], env);
+    const needle = lexicalValue(goal.args[1], env);
+    if (haystack == null || needle == null) return;
+    const has = haystack.includes(needle);
+    const matches = simpleAlternationMatch(haystack, needle);
+    const pass = (name === '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;
+}

package/src/builtins/terms.js

@@ -0,0 +1,66 @@
+// Term-inspection builtins for reusable meta-programming over eyelang terms.
+import { atom, compound, deref, listFromItems, lexicalValue, numberTerm, properListItems, stringTerm, unify } from '../term.js';
+
+export const termBuiltins = {
+  register(registry) {
+    registry.add('functor', 3, functorBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
+    registry.add('arg', 3, argBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: argReady });
+    registry.add('compound_name_arguments', 3, compoundNameArguments, { deterministic: true, fallbackWhenNotReady: true, ready: compoundNameArgumentsReady });
+  }
+};
+
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
+function argReady(goal, env) {
+  return /^\d+$/.test(lexicalValue(goal.args[0], env) ?? '') && deref(goal.args[1], env).type === 'compound';
+}
+
+function compoundNameArgumentsReady(goal, env) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') return true;
+  return term.type === 'var' && lexicalValue(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
+function* functorBuiltin({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const nameTerm = term.type === 'compound' ? atom(term.name) : scalarNameTerm(term);
+  const arity = term.type === 'compound' ? term.arity : 0;
+  const next = env.clone();
+  if (unify(goal.args[1], nameTerm, next) && unify(goal.args[2], numberTerm(arity), next)) yield next;
+}
+
+function* argBuiltin({ goal, env }) {
+  const indexText = lexicalValue(goal.args[0], env);
+  if (!/^\d+$/.test(indexText ?? '')) return;
+  const index = Number(indexText);
+  const term = deref(goal.args[1], env);
+  if (term.type !== 'compound' || !Number.isSafeInteger(index) || index < 1 || index > term.arity) return;
+  const next = env.clone();
+  if (unify(goal.args[2], term.args[index - 1], next)) yield next;
+}
+
+function* compoundNameArguments({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') {
+    const next = env.clone();
+    if (unify(goal.args[1], atom(term.name), next) && unify(goal.args[2], listFromItems(term.args), next)) yield next;
+    return;
+  }
+  if (term.type !== 'var') return;
+
+  const name = lexicalValue(goal.args[1], env);
+  const args = properListItems(goal.args[2], env);
+  if (name == null || !args) return;
+  const next = env.clone();
+  if (unify(goal.args[0], compound(name, args), next)) yield next;
+}
+
+function scalarNameTerm(term) {
+  if (term.type === 'atom') return atom(term.name);
+  if (term.type === 'number') return numberTerm(term.name);
+  return stringTerm(term.name);
+}