eyeling 1.32.1 → 1.33.0

package/lib/eyelang/builtins/control.mjs

@@ -0,0 +1,22 @@
+// Control builtins.  These intentionally use bounded nested solvers so not/1 and once/1 only ask for the answers they need.
+export const controlBuiltins = {
+  register(registry) {
+    registry.add('not', 1, notBuiltin);
+    registry.add('once', 1, onceBuiltin);
+  }
+};
+
+function* notBuiltin({ solver, goal, env }) {
+  const limited = solver.cloneForInnerGoal(1);
+  let found = false;
+  for (const _ of limited.solve([goal.args[0]], env.clone(), 0)) { found = true; break; }
+  if (!found) yield env;
+}
+
+function* onceBuiltin({ solver, goal, env }) {
+  const limited = solver.cloneForInnerGoal(1);
+  for (const answerEnv of limited.solve([goal.args[0]], env.clone(), 0)) {
+    yield answerEnv;
+    break;
+  }
+}

package/lib/eyelang/builtins/core.mjs

@@ -0,0 +1,78 @@
+// Core relational builtins that do not naturally belong to arithmetic, strings, lists, or aggregation.
+// They are deterministic filters/projections and should avoid enumerating additional answers.
+import { stringTerm, lexicalValue, unify } from '../term.mjs';
+
+function* ok(env) { yield env; }
+
+export const coreBuiltins = {
+  register(registry) {
+    registry.add('eq', 2, function* ({ goal, env }) {
+      const next = env.clone();
+      if (unify(goal.args[0], goal.args[1], next)) yield next;
+    }, { deterministic: true });
+
+    registry.add('neq', 2, function* ({ goal, env }) {
+      const attempt = env.clone();
+      if (!unify(goal.args[0], goal.args[1], attempt)) yield env;
+    }, { deterministic: true });
+
+    registry.add('local_time', 1, function* ({ goal, env }) {
+      const next = env.clone();
+      if (unify(goal.args[0], stringTerm(localDateText()), next)) yield next;
+    }, { deterministic: true });
+
+    registry.add('difference', 3, function* ({ goal, env }) {
+      const endText = lexicalValue(goal.args[0], env);
+      const startText = lexicalValue(goal.args[1], env);
+      if (!endText || !startText) return;
+      const end = parseISODate(endText);
+      const start = parseISODate(startText);
+      if (!end || !start || compareDateParts(end, start) < 0) return;
+      let [ey, em, ed] = end;
+      const [sy, sm, sd] = start;
+      if (ed < sd) {
+        let bm = em - 1;
+        let by = ey;
+        if (bm === 0) { bm = 12; by--; }
+        ed += daysInMonth(by, bm);
+        em--;
+        if (em === 0) { em = 12; ey--; }
+      }
+      if (em < sm) { em += 12; ey--; }
+      const duration = formatDuration(ey - sy, em - sm, ed - sd);
+      const next = env.clone();
+      if (unify(goal.args[2], stringTerm(duration), next)) yield next;
+    }, { deterministic: true });
+  }
+};
+
+
+function localDateText() {
+  const fixed = typeof process !== 'undefined' ? process.env?.EYELANG_LOCAL_TIME : null;
+  if (fixed) return fixed;
+
+  const now = new Date();
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, '0');
+  const dd = String(now.getDate()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}`;
+}
+
+function parseISODate(text) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(text);
+  if (!m) return null;
+  const y = Number(m[1]), mo = Number(m[2]), d = Number(m[3]);
+  if (mo < 1 || mo > 12 || d < 1 || d > daysInMonth(y, mo)) return null;
+  return [y, mo, d];
+}
+function daysInMonth(y, m) {
+  return [0,31,((y%4===0&&y%100!==0)||y%400===0)?29:28,31,30,31,30,31,31,30,31,30,31][m] ?? 0;
+}
+function compareDateParts(a, b) {
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
+  return 0;
+}
+function formatDuration(y, m, d) {
+  if (y === 0 && m === 0 && d === 0) return 'P0D';
+  return `P${y ? `${y}Y` : ''}${m ? `${m}M` : ''}${d ? `${d}D` : ''}`;
+}

package/lib/eyelang/builtins/formula.mjs

@@ -0,0 +1,42 @@
+// Formula builtins that treat conjunctions as first-class data terms.
+// These are used by examples that construct or inspect rule bodies programmatically.
+import { atom, deref, isConjunction, unify } from '../term.mjs';
+
+export const formulaBuiltins = {
+  register(registry) {
+    registry.add('formula_atom', 2, formulaAtom);
+    registry.add('formula_binary', 4, formulaBinary);
+  }
+};
+
+function* emitFormulaAtoms(formula, target, env) {
+  formula = deref(formula, env);
+  if (isConjunction(formula)) {
+    yield* emitFormulaAtoms(formula.args[0], target, env);
+    yield* emitFormulaAtoms(formula.args[1], target, env);
+    return;
+  }
+  if (formula.type !== 'compound') return;
+  const next = env.clone();
+  if (unify(target, formula, next)) yield next;
+}
+
+function* formulaAtom({ goal, env }) {
+  yield* emitFormulaAtoms(goal.args[0], goal.args[1], env);
+}
+
+function* emitFormulaBinary(formula, subject, predicate, object, env) {
+  formula = deref(formula, env);
+  if (isConjunction(formula)) {
+    yield* emitFormulaBinary(formula.args[0], subject, predicate, object, env);
+    yield* emitFormulaBinary(formula.args[1], subject, predicate, object, env);
+    return;
+  }
+  if (formula.type !== 'compound' || formula.arity !== 2) return;
+  const next = env.clone();
+  if (unify(subject, formula.args[0], next) && unify(predicate, atom(formula.name), next) && unify(object, formula.args[1], next)) yield next;
+}
+
+function* formulaBinary({ goal, env }) {
+  yield* emitFormulaBinary(goal.args[0], goal.args[1], goal.args[2], goal.args[3], env);
+}

package/lib/eyelang/builtins/lists.mjs

@@ -0,0 +1,149 @@
+// List builtins for proper lists, selection, membership, sorting, and indexing.
+// 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.mjs';
+
+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('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('sort', 2, sortBuiltin, { deterministic: true });
+  }
+};
+
+
+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 indexText = lexicalValue(goal.args[0], env);
+  if (!/^-?\d+$/.test(indexText ?? '')) return;
+  const index = Number(indexText);
+  if (!Number.isSafeInteger(index) || index < 0) 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* 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* 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* isList({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (items) yield env;
+}
+
+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;
+}

package/lib/eyelang/builtins/matrix.mjs

@@ -0,0 +1,226 @@
+// Small dense-matrix arithmetic builtins.
+// These are reusable numeric kernels for ground matrices; when arguments are not
+// ground proper numeric lists, user-defined matrix predicates remain available.
+import { deref, isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, properListItems, unify } from '../term.mjs';
+
+export const matrixBuiltins = {
+  register(registry) {
+    registry.add('matrix_sum', 2, matrixSum, { deterministic: true, fallbackWhenNotReady: true, ready: matrixPairReady });
+    registry.add('matrix_multiply', 2, matrixMultiply, { deterministic: true, fallbackWhenNotReady: true, ready: matrixPairReady });
+    registry.add('cholesky_decomposition', 2, choleskyDecomposition, { deterministic: true, fallbackWhenNotReady: true, ready: firstMatrixReady });
+    registry.add('determinant', 2, determinant, { deterministic: true, fallbackWhenNotReady: true, ready: firstMatrixReady });
+    registry.add('matrix_inv_triang', 2, matrixInvTriang, { deterministic: true, fallbackWhenNotReady: true, ready: firstMatrixReady });
+    registry.add('matrix_inversion', 2, matrixInversion, { deterministic: true, fallbackWhenNotReady: true, ready: firstMatrixReady });
+  }
+};
+
+function firstMatrixReady(goal, env) { return parseMatrix(goal.args[0], env) !== null; }
+function matrixPairReady(goal, env) { return parseMatrixPair(goal.args[0], env) !== null; }
+
+function* matrixSum({ goal, env }) {
+  const pair = parseMatrixPair(goal.args[0], env);
+  if (!pair) return;
+  const [a, b] = pair;
+  if (!sameShape(a, b)) return;
+  const out = a.map((row, i) => row.map((cell, j) => addNum(cell, b[i][j])));
+  yield* unifyMatrix(goal.args[1], out, env);
+}
+
+function* matrixMultiply({ goal, env }) {
+  const pair = parseMatrixPair(goal.args[0], env);
+  if (!pair) return;
+  const out = multiplyMatrices(pair[0], pair[1]);
+  if (!out) return;
+  yield* unifyMatrix(goal.args[1], out, env);
+}
+
+function* choleskyDecomposition({ goal, env }) {
+  const matrix = parseMatrix(goal.args[0], env);
+  const out = cholesky(matrix);
+  if (!out) return;
+  yield* unifyMatrix(goal.args[1], out, env);
+}
+
+function* determinant({ goal, env }) {
+  const matrix = parseMatrix(goal.args[0], env);
+  const l = cholesky(matrix);
+  if (!l) return;
+  let prod = num(1n);
+  for (let i = l.length - 1; i >= 0; i--) prod = mulNum(l[i][i], prod);
+  const det = mulNum(prod, prod);
+  const next = env.clone();
+  if (unify(goal.args[1], numTerm(det), next)) yield next;
+}
+
+function* matrixInvTriang({ goal, env }) {
+  const matrix = parseMatrix(goal.args[0], env);
+  const out = invertLowerTriangular(matrix);
+  if (!out) return;
+  yield* unifyMatrix(goal.args[1], out, env);
+}
+
+function* matrixInversion({ goal, env }) {
+  const matrix = parseMatrix(goal.args[0], env);
+  const l = cholesky(matrix);
+  if (!l) return;
+  const li = invertLowerTriangular(l);
+  if (!li) return;
+  const lit = transpose(li);
+  const out = multiplyMatrices(lit, li);
+  if (!out) return;
+  yield* unifyMatrix(goal.args[1], out, env);
+}
+
+function cholesky(a) {
+  if (!isSquare(a)) return null;
+  const n = a.length;
+  const l = Array.from({ length: n }, () => Array.from({ length: n }, () => num(0n)));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let sum = num(0n);
+      for (let k = 0; k < j; k++) sum = addNum(sum, mulNum(l[i][k], l[j][k]));
+      if (j === i) {
+        const v2 = subNum(a[i][i], sum);
+        const v = Math.sqrt(toNumber(v2));
+        if (!Number.isFinite(v)) return null;
+        l[i][j] = num(v);
+      } else {
+        const numerator = subNum(a[i][j], sum);
+        l[i][j] = divNum(numerator, l[j][j]);
+      }
+    }
+  }
+  return l;
+}
+
+function invertLowerTriangular(l) {
+  if (!isSquare(l)) return null;
+  const n = l.length;
+  const previous = [];
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const row = [];
+    for (let j = 0; j < n; j++) {
+      if (j > i) row.push(num(0n));
+      else if (i === j) row.push(divNum(num(1), l[i][i]));
+      else {
+        let sum = num(0n);
+        for (let k = j; k < i; k++) sum = addNum(sum, mulNum(l[i][k], previous[k][j]));
+        row.push(divNum(negNum(sum), l[i][i]));
+      }
+    }
+    previous.push(row);
+    out.push(row);
+  }
+  return out;
+}
+
+function multiplyMatrices(a, b) {
+  if (!a.length || !b.length || !a[0].length || !b[0].length) return null;
+  const rows = a.length, inner = a[0].length, cols = b[0].length;
+  if (b.length !== inner || a.some((row) => row.length !== inner) || b.some((row) => row.length !== cols)) return null;
+  const out = [];
+  for (let i = 0; i < rows; i++) {
+    const row = [];
+    for (let j = 0; j < cols; j++) {
+      let total = num(0n);
+      for (let k = inner - 1; k >= 0; k--) total = addNum(mulNum(a[i][k], b[k][j]), total);
+      row.push(total);
+    }
+    out.push(row);
+  }
+  return out;
+}
+
+function transpose(a) {
+  if (!a.length) return [];
+  return a[0].map((_, i) => a.map((row) => row[i]));
+}
+
+function sameShape(a, b) {
+  return a.length === b.length && a.every((row, i) => row.length === b[i].length);
+}
+
+function isSquare(a) {
+  return Array.isArray(a) && a.length > 0 && a.every((row) => row.length === a.length);
+}
+
+function parseMatrixPair(term, env) {
+  const pair = properListItems(term, env);
+  if (!pair || pair.length !== 2) return null;
+  const a = parseMatrix(pair[0], env), b = parseMatrix(pair[1], env);
+  return a && b ? [a, b] : null;
+}
+
+function parseMatrix(term, env) {
+  const rows = properListItems(term, env);
+  if (!rows) return null;
+  const matrix = [];
+  let width = null;
+  for (const rowTerm of rows) {
+    const rowItems = properListItems(rowTerm, env);
+    if (!rowItems) return null;
+    if (width == null) width = rowItems.length;
+    else if (width !== rowItems.length) return null;
+    const row = [];
+    for (const item of rowItems) {
+      const n = parseNum(item, env);
+      if (!n) return null;
+      row.push(n);
+    }
+    matrix.push(row);
+  }
+  return matrix;
+}
+
+function parseNum(term, env) {
+  const value = deref(term, env);
+  if (value.type !== 'number') return null;
+  if (isDecimalInteger(value.name)) return num(BigInt(value.name));
+  const f = parseFiniteNumber(value.name);
+  return f == null ? null : num(f);
+}
+
+function* unifyMatrix(target, matrix, env) {
+  const next = env.clone();
+  if (unify(target, matrixTerm(matrix), next)) yield next;
+}
+
+function matrixTerm(matrix) {
+  return listFromItems(matrix.map((row) => listFromItems(row.map(numTerm))));
+}
+
+function numTerm(value) {
+  if (value.kind === 'int') return numberTerm(value.value.toString());
+  return numberTerm(numberTextFromDouble(value.value));
+}
+
+function num(value) {
+  return typeof value === 'bigint' ? { kind: 'int', value } : { kind: 'float', value: Number(value) };
+}
+
+function toNumber(value) {
+  return value.kind === 'int' ? Number(value.value) : value.value;
+}
+
+function addNum(a, b) {
+  if (a.kind === 'int' && b.kind === 'int') return num(a.value + b.value);
+  return num(toNumber(a) + toNumber(b));
+}
+function subNum(a, b) {
+  if (a.kind === 'int' && b.kind === 'int') return num(a.value - b.value);
+  return num(toNumber(a) - toNumber(b));
+}
+function mulNum(a, b) {
+  if (a.kind === 'int' && b.kind === 'int') return num(a.value * b.value);
+  return num(toNumber(a) * toNumber(b));
+}
+function divNum(a, b) {
+  if (b.kind === 'int' && b.value === 0n) return num(Number.NaN);
+  if (b.kind === 'float' && b.value === 0) return num(Number.NaN);
+  if (a.kind === 'int' && b.kind === 'int' && a.value % b.value === 0n) return num(a.value / b.value);
+  return num(toNumber(a) / toNumber(b));
+}
+function negNum(a) {
+  return a.kind === 'int' ? num(-a.value) : num(-a.value);
+}