eyeling 1.34.5 → 1.34.6

package/lib/eyelang/builtins/lists.js

@@ -1,283 +0,0 @@
-// 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/lib/eyelang/builtins/registry.js

@@ -1,48 +0,0 @@
-// 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/lib/eyelang/builtins/strings.js

@@ -1,234 +0,0 @@
-// 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/lib/eyelang/builtins/terms.js

@@ -1,66 +0,0 @@
-// 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);
-}