eyelang 1.6.0 → 1.7.0

package/playground-worker.mjs

@@ -1,141 +0,0 @@
-// Browser worker used by playground.html.
-// It keeps parsing and solving off the UI thread and returns only serializable results to the page.
-let active = false;
-let modulePromise = null;
-let engine = null;
-
-function stringifyError(error) {
-  if (!error) return 'Unknown error';
-
-  const message = error.message ? String(error.message) : String(error);
-  const stack = error.stack ? String(error.stack) : message;
-
-  if (/Maximum call stack size exceeded|call stack|stack overflow/i.test(stack)) {
-    return [
-      stack,
-      '',
-      'eyelang exhausted the browser JavaScript call stack.',
-      'Try a smaller example in the playground, or run this program with the Node CLI.',
-    ].join('\n');
-  }
-
-  return stack;
-}
-
-async function loadEngine() {
-  if (engine) return engine;
-  if (!modulePromise) modulePromise = import('./src/index.js');
-  engine = await modulePromise;
-  return engine;
-}
-
-async function initialize(requestId) {
-  try {
-    await loadEngine();
-    self.postMessage({ type: 'ready', id: requestId });
-  } catch (error) {
-    modulePromise = null;
-    engine = null;
-    self.postMessage({
-      type: 'init-error',
-      id: requestId,
-      phase: 'loading JavaScript engine',
-      stderr: stringifyError(error),
-    });
-  }
-}
-
-async function runEyelang(request) {
-  const { id, program, stats, proof = false } = request;
-  if (active) {
-    self.postMessage({
-      type: 'result',
-      id,
-      exitCode: 1,
-      phase: 'starting eyelang',
-      stdout: '',
-      stderr: 'eyelang is already running.',
-    });
-    return;
-  }
-
-  active = true;
-  let exitCode = 0;
-  let phase = 'running JavaScript engine';
-  let stdout = '';
-  let stderr = '';
-
-  try {
-    const {
-      COMPOUND,
-      Env,
-      Program,
-      Solver,
-      copyResolved,
-      termIsGround,
-      termToString,
-      whyNoProof,
-      whyProof,
-    } = await loadEngine();
-
-    phase = 'parsing input';
-    const parsed = Program.parse(program || '', { filename: '<playground>', sourceMetadata: proof, markRecursive: proof });
-
-    {
-      phase = 'materializing output';
-      const goals = parsed.materializationGoals();
-      const materializedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-      const facts = parsed.sourceFactLines(materializedKeys);
-      const lines = new Set();
-      const out = [];
-      let lastStats = null;
-      for (const goal of goals) {
-        if (goal.type !== COMPOUND) continue;
-        const solver = new Solver(parsed);
-        for (const env of solver.solve([goal], new Env(), 0)) {
-          const resolved = copyResolved(goal, env);
-          if (!termIsGround(resolved)) continue;
-          const line = `${termToString(resolved, new Env(), true)}.\n`;
-          if (facts.has(line) || lines.has(line)) continue;
-          lines.add(line);
-          out.push(line);
-          if (proof) appendExplanation(out, parsed, resolved, whyProof, whyNoProof);
-        }
-        lastStats = solver.stats;
-      }
-      stdout = out.join('');
-      if (stats && lastStats) stderr = formatStats(lastStats);
-    }
-  } catch (error) {
-    exitCode = 1;
-    stderr = stringifyError(error);
-  } finally {
-    self.postMessage({
-      type: 'result',
-      id,
-      exitCode,
-      phase,
-      stdout,
-      stderr,
-    });
-    active = false;
-  }
-}
-
-function appendExplanation(out, program, resolved, whyProof, whyNoProof) {
-  const proof = whyProof(program, resolved);
-  out.push(proof.text);
-  if (!proof.ok) out.push(whyNoProof(resolved));
-}
-
-function formatStats(stats) {
-  let text = 'eyelang stats:\n';
-  for (const [key, value] of Object.entries(stats)) text += `  ${key}: ${value}\n`;
-  return text;
-}
-
-self.onmessage = event => {
-  const message = event.data || {};
-  if (message.type === 'init') initialize(message.id);
-  else if (message.type === 'run') runEyelang(message);
-};

package/src/builtins/alphametic.js

@@ -1,144 +0,0 @@
-// Reusable alphametic addition solver.
-// It evaluates column constraints right-to-left, so examples such as
-// SEND+MORE=MONEY and DONALD+GERALD=ROBERT do not need to express digit search
-// with many relational select/3 and arithmetic goals.
-import { atom, deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
-
-export const alphameticBuiltins = {
-  register(registry) {
-    registry.add('alphametic_sum', 5, alphameticSum, {
-      fallbackWhenNotReady: true,
-      ready: alphameticReady,
-    });
-  }
-};
-
-function alphameticReady(goal, env) {
-  return atomList(goal.args[0], env) !== null && wordList(goal.args[1], env) !== null && atomList(goal.args[2], env) !== null;
-}
-
-function* alphameticSum({ goal, env }) {
-  const letters = atomList(goal.args[0], env);
-  const addends = wordList(goal.args[1], env);
-  const result = atomList(goal.args[2], env);
-  if (!letters || !addends || !result || letters.length > 10 || addends.length === 0) return;
-
-  const letterSet = new Set(letters);
-  for (const word of [...addends, result]) for (const letter of word) if (!letterSet.has(letter)) return;
-
-  const leading = new Set();
-  for (const word of [...addends, result]) if (word.length > 1) leading.add(word[0]);
-  const maxLen = Math.max(result.length, ...addends.map((word) => word.length));
-  const assignment = new Map();
-  const used = Array(10).fill(false);
-
-  function canUse(letter, digit) {
-    return !used[digit] && !(digit === 0 && leading.has(letter));
-  }
-
-  function assignDigit(letter, digit) {
-    assignment.set(letter, digit);
-    used[digit] = true;
-  }
-
-  function unassignDigit(letter, digit) {
-    assignment.delete(letter);
-    used[digit] = false;
-  }
-
-  function* assignAddends(column, carry, index, sum) {
-    if (index >= addends.length) {
-      yield* finishColumn(column, sum);
-      return;
-    }
-    const word = addends[index];
-    const letter = word[word.length - 1 - column];
-    if (letter === undefined) {
-      yield* assignAddends(column, carry, index + 1, sum);
-      return;
-    }
-    const assigned = assignment.get(letter);
-    if (assigned !== undefined) {
-      yield* assignAddends(column, carry, index + 1, sum + assigned);
-      return;
-    }
-    for (let digit = 0; digit <= 9; digit++) {
-      if (!canUse(letter, digit)) continue;
-      assignDigit(letter, digit);
-      yield* assignAddends(column, carry, index + 1, sum + digit);
-      unassignDigit(letter, digit);
-    }
-  }
-
-  function* finishColumn(column, sum) {
-    const resultLetter = result[result.length - 1 - column];
-    const digit = sum % 10;
-    const nextCarry = Math.floor(sum / 10);
-    if (resultLetter === undefined) {
-      if (digit === 0) yield* solveColumn(column + 1, nextCarry);
-      return;
-    }
-    const assigned = assignment.get(resultLetter);
-    if (assigned !== undefined) {
-      if (assigned === digit) yield* solveColumn(column + 1, nextCarry);
-      return;
-    }
-    if (!canUse(resultLetter, digit)) return;
-    assignDigit(resultLetter, digit);
-    yield* solveColumn(column + 1, nextCarry);
-    unassignDigit(resultLetter, digit);
-  }
-
-  function* solveColumn(column, carry) {
-    if (column >= maxLen) {
-      if (carry !== 0) return;
-      if (assignment.size !== letters.length) return;
-      yield new Map(assignment);
-      return;
-    }
-    yield* assignAddends(column, carry, 0, carry);
-  }
-
-  for (const solution of solveColumn(0, 0)) {
-    const digitTerms = letters.map((letter) => numberTerm(String(solution.get(letter))));
-    const values = [...addends, result].map((word) => wordValue(word, solution));
-    const valueTerms = values.map((value) => numberTerm(String(value)));
-    const next = env.clone();
-    if (unify(goal.args[3], listFromItems(digitTerms), next) && unify(goal.args[4], listFromItems(valueTerms), next)) yield next;
-  }
-}
-
-function wordValue(word, assignment) {
-  let value = 0;
-  for (const letter of word) value = value * 10 + assignment.get(letter);
-  return value;
-}
-
-function atomList(term, env) {
-  const items = properListItems(term, env);
-  if (!items) return null;
-  const out = [];
-  for (const item of items) {
-    const text = atomKey(deref(item, env));
-    if (text == null) return null;
-    out.push(text);
-  }
-  return out;
-}
-
-function wordList(term, env) {
-  const items = properListItems(term, env);
-  if (!items) return null;
-  const out = [];
-  for (const item of items) {
-    const word = atomList(item, env);
-    if (!word) return null;
-    out.push(word);
-  }
-  return out;
-}
-
-function atomKey(term) {
-  if (term.type === 'atom' || term.type === 'string' || term.type === 'number') return term.name;
-  return null;
-}

package/src/builtins/formula.js

@@ -1,42 +0,0 @@
-// 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.js';
-
-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/src/builtins/matrix.js

@@ -1,226 +0,0 @@
-// 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.js';
-
-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);
-}