@hviana/sema 0.1.5 → 0.1.7

package/dist/src/alu/src/expr.js

@@ -26,8 +26,7 @@ const isDigit = (c) => c >= "0" && c <= "9";
 // so a variable or function name may be written in any script (multimodal /
 // multilingual), not just A–Z.  Operator glyphs (registered symbolic forms)
 // are claimed BEFORE identifiers, so "·" and "≤" never read as names.
-const isLetter = (c) =>
-  (c >= "A" && c <= "Z") || (c >= "a" && c <= "z") || c.charCodeAt(0) > 127;
+const isLetter = (c) => (c >= "A" && c <= "Z") || (c >= "a" && c <= "z") || c.charCodeAt(0) > 127;
 const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r";
 /** Tokenize an expression string: numerals (the irreducible floor), operator
  *  tokens (matched longest-first against `operators` — the registry's own
@@ -36,114 +35,107 @@ const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r";
  *  extraction).  Returns null when a character fits none of these — the span is
  *  not a clean expression. */
 export function tokenize(s, operators) {
-  const toks = [];
-  let i = 0;
-  while (i < s.length) {
-    const c = s[i];
-    if (isSpace(c)) {
-      i++;
-      continue;
-    }
-    if (isDigit(c) || (c === "." && i + 1 < s.length && isDigit(s[i + 1]))) {
-      let j = i;
-      let seenDot = false;
-      while (j < s.length) {
-        if (isDigit(s[j])) {
-          j++;
-        } else if (s[j] === "." && !seenDot) {
-          seenDot = true;
-          j++;
-        } else {
-          break;
+    const toks = [];
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (isSpace(c)) {
+            i++;
+            continue;
         }
-      }
-      // optional exponent
-      if (j < s.length && (s[j] === "e" || s[j] === "E")) {
-        let k = j + 1;
-        if (k < s.length && (s[k] === "+" || s[k] === "-")) {
-          k++;
+        if (isDigit(c) || (c === "." && i + 1 < s.length && isDigit(s[i + 1]))) {
+            let j = i;
+            let seenDot = false;
+            while (j < s.length) {
+                if (isDigit(s[j]))
+                    j++;
+                else if (s[j] === "." && !seenDot) {
+                    seenDot = true;
+                    j++;
+                }
+                else
+                    break;
+            }
+            // optional exponent
+            if (j < s.length && (s[j] === "e" || s[j] === "E")) {
+                let k = j + 1;
+                if (k < s.length && (s[k] === "+" || s[k] === "-"))
+                    k++;
+                if (k < s.length && isDigit(s[k])) {
+                    while (k < s.length && isDigit(s[k]))
+                        k++;
+                    j = k;
+                }
+            }
+            const text = s.slice(i, j);
+            const num = Number(text);
+            if (!Number.isFinite(num))
+                return null;
+            toks.push({ kind: "num", text, value: num });
+            i = j;
+            continue;
         }
-        if (k < s.length && isDigit(s[k])) {
-          while (k < s.length && isDigit(s[k])) {
-            k++;
-          }
-          j = k;
+        if (c === "(") {
+            toks.push({ kind: "lparen", text: c });
+            i++;
+            continue;
         }
-      }
-      const text = s.slice(i, j);
-      const num = Number(text);
-      if (!Number.isFinite(num)) {
-        return null;
-      }
-      toks.push({ kind: "num", text, value: num });
-      i = j;
-      continue;
-    }
-    if (c === "(") {
-      toks.push({ kind: "lparen", text: c });
-      i++;
-      continue;
-    }
-    if (c === ")") {
-      toks.push({ kind: "rparen", text: c });
-      i++;
-      continue;
-    }
-    // A registered symbolic operator form, longest first — claimed before the
-    // identifier path so an operator GLYPH (·, ×, ≤, …) is an operator, not a
-    // name.
-    const op = operators?.find((f) => s.startsWith(f, i));
-    if (op !== undefined) {
-      toks.push({ kind: "op", text: op });
-      i += op.length;
-      continue;
-    }
-    if (isLetter(c)) {
-      let j = i;
-      while (j < s.length && (isLetter(s[j]) || isDigit(s[j]))) {
-        j++;
-      }
-      toks.push({ kind: "name", text: s.slice(i, j) });
-      i = j;
-      continue;
-    }
-    // Fallback for a symbolic character outside any vocabulary: its own token,
-    // so name extraction (freeVariables) still splits "a*b" without a grammar.
-    if (operators === undefined) {
-      toks.push({ kind: "op", text: c });
-      i++;
-      continue;
+        if (c === ")") {
+            toks.push({ kind: "rparen", text: c });
+            i++;
+            continue;
+        }
+        // A registered symbolic operator form, longest first — claimed before the
+        // identifier path so an operator GLYPH (·, ×, ≤, …) is an operator, not a
+        // name.
+        const op = operators?.find((f) => s.startsWith(f, i));
+        if (op !== undefined) {
+            toks.push({ kind: "op", text: op });
+            i += op.length;
+            continue;
+        }
+        if (isLetter(c)) {
+            let j = i;
+            while (j < s.length && (isLetter(s[j]) || isDigit(s[j])))
+                j++;
+            toks.push({ kind: "name", text: s.slice(i, j) });
+            i = j;
+            continue;
+        }
+        // Fallback for a symbolic character outside any vocabulary: its own token,
+        // so name extraction (freeVariables) still splits "a*b" without a grammar.
+        if (operators === undefined) {
+            toks.push({ kind: "op", text: c });
+            i++;
+            continue;
+        }
+        return null; // an unexpected character → not a clean expression
     }
-    return null; // an unexpected character → not a clean expression
-  }
-  return toks;
+    return toks;
 }
 /** The identifiers in `s` that are NOT known unary functions and NOT registered
  *  constants — the free-variable candidates.  Used to auto-detect the variable
  *  when the caller did not name one. */
 export function freeVariables(s, isUnaryFn, isConstant = () => false) {
-  const toks = tokenize(s);
-  if (!toks) {
-    return [];
-  }
-  const out = [];
-  const seen = new Set();
-  for (let k = 0; k < toks.length; k++) {
-    const t = toks[k];
-    if (t.kind !== "name") {
-      continue;
-    }
-    // A name immediately followed by "(" is a function call, not a variable.
-    const isCall = k + 1 < toks.length && toks[k + 1].kind === "lparen";
-    if (isCall || isUnaryFn(t.text) || isConstant(t.text)) {
-      continue;
-    }
-    if (!seen.has(t.text)) {
-      seen.add(t.text);
-      out.push(t.text);
+    const toks = tokenize(s);
+    if (!toks)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (let k = 0; k < toks.length; k++) {
+        const t = toks[k];
+        if (t.kind !== "name")
+            continue;
+        // A name immediately followed by "(" is a function call, not a variable.
+        const isCall = k + 1 < toks.length && toks[k + 1].kind === "lparen";
+        if (isCall || isUnaryFn(t.text) || isConstant(t.text))
+            continue;
+        if (!seen.has(t.text)) {
+            seen.add(t.text);
+            out.push(t.text);
+        }
     }
-  }
-  return out;
+    return out;
 }
 /** The expression grammar, read off an operation registry once and reused for
  *  every evaluation.  It resolves each token through the registry's own form
@@ -151,194 +143,176 @@ export function freeVariables(s, isUnaryFn, isConstant = () => false) {
  *  arity-1 claimant of a shared symbol, functions as arity-1 ops, constants as
  *  arity-0 ops — so the grammar and the kernel can never drift apart. */
 export class ExprGrammar {
-  registry;
-  applyScalar;
-  /** Symbolic operator tokens, longest first (so "<=" wins over "<"). */
-  operatorTokens;
-  /** token → the infix op it names and its declared binding. */
-  infixTable = new Map();
-  /** token → the arity-1 (prefix) op it names. */
-  prefixTable = new Map();
-  /** The tightest infix tier — a prefix operator binds its operand up through
-   *  it, so "-x^2" reads -(x^2) without a hardcoded rule. */
-  maxPrecedence;
-  constructor(registry, applyScalar) {
-    this.registry = registry;
-    this.applyScalar = applyScalar;
-    const tokens = new Set();
-    let maxPrec = 0;
-    for (const { form, name } of registry.formEntries()) {
-      const op = registry.get(name);
-      const symbolic = form.length > 0 && !/[A-Za-z0-9]/.test(form);
-      if (!symbolic) {
-        continue;
-      }
-      tokens.add(form);
-      if (op.infix && !this.infixTable.has(form)) {
-        this.infixTable.set(form, { name, syntax: op.infix });
-        maxPrec = Math.max(maxPrec, op.infix.precedence);
-      }
-      if (op.arity === 1 && !this.prefixTable.has(form)) {
-        this.prefixTable.set(form, name);
-      }
+    registry;
+    applyScalar;
+    /** Symbolic operator tokens, longest first (so "<=" wins over "<"). */
+    operatorTokens;
+    /** token → the infix op it names and its declared binding. */
+    infixTable = new Map();
+    /** token → the arity-1 (prefix) op it names. */
+    prefixTable = new Map();
+    /** The tightest infix tier — a prefix operator binds its operand up through
+     *  it, so "-x^2" reads -(x^2) without a hardcoded rule. */
+    maxPrecedence;
+    constructor(registry, applyScalar) {
+        this.registry = registry;
+        this.applyScalar = applyScalar;
+        const tokens = new Set();
+        let maxPrec = 0;
+        for (const { form, name } of registry.formEntries()) {
+            const op = registry.get(name);
+            const symbolic = form.length > 0 && !/[A-Za-z0-9]/.test(form);
+            if (!symbolic)
+                continue;
+            tokens.add(form);
+            if (op.infix && !this.infixTable.has(form)) {
+                this.infixTable.set(form, { name, syntax: op.infix });
+                maxPrec = Math.max(maxPrec, op.infix.precedence);
+            }
+            if (op.arity === 1 && !this.prefixTable.has(form)) {
+                this.prefixTable.set(form, name);
+            }
+        }
+        this.operatorTokens = [...tokens].sort((a, b) => b.length - a.length);
+        this.maxPrecedence = maxPrec;
     }
-    this.operatorTokens = [...tokens].sort((a, b) => b.length - a.length);
-    this.maxPrecedence = maxPrec;
-  }
-  /** Resolve an identifier to a registered op of the given arity: a surface
-   *  form claimant of that arity first, else the canonical name itself. */
-  resolveName(name, arity) {
-    for (const n of this.registry.lookupForm(name)) {
-      if (this.registry.get(n).arity === arity) {
-        return n;
-      }
+    /** Resolve an identifier to a registered op of the given arity: a surface
+     *  form claimant of that arity first, else the canonical name itself. */
+    resolveName(name, arity) {
+        for (const n of this.registry.lookupForm(name)) {
+            if (this.registry.get(n).arity === arity)
+                return n;
+        }
+        const own = this.registry.get(name);
+        return own && own.arity === arity ? name : null;
     }
-    const own = this.registry.get(name);
-    return own && own.arity === arity ? name : null;
-  }
-  /** Whether an identifier names a unary function. */
-  isFunction(name) {
-    return this.resolveName(name, 1) !== null;
-  }
-  /** Whether an identifier names a nullary constant (an arity-0 op). */
-  isConstant(name) {
-    return this.resolveName(name, 0) !== null;
-  }
-  /** Tokenize with this grammar's operator vocabulary. */
-  tokenize(s) {
-    return tokenize(s, this.operatorTokens);
-  }
-  /** The free-variable candidates of `s` under this grammar. */
-  freeVariables(s) {
-    return freeVariables(
-      s,
-      (n) => this.isFunction(n),
-      (n) => this.isConstant(n),
-    );
-  }
-  /** Evaluate expression `s` with `variable` bound to `at`.  Returns a number,
-   *  or null if `s` is not a well-formed expression.  Every binary/function/
-   *  constant step is applied through the kernel, so the arithmetic is the
-   *  kernel's own.  When `variable` is empty, the single free variable is
-   *  auto-detected; if there is more than one and none was named, evaluation
-   *  declines (null) — a genuinely multivariate expression needs an explicit
-   *  binding. */
-  eval(s, variable, at) {
-    const toks = this.tokenize(s);
-    if (!toks || toks.length === 0) {
-      return null;
+    /** Whether an identifier names a unary function. */
+    isFunction(name) {
+        return this.resolveName(name, 1) !== null;
     }
-    let v = variable;
-    if (v === "") {
-      const fv = this.freeVariables(s);
-      if (fv.length === 1) {
-        v = fv[0];
-      } else if (fv.length > 1) {
-        return null; // multivariate, no binding named
-      }
-      // fv.length === 0: a constant expression is fine.
+    /** Whether an identifier names a nullary constant (an arity-0 op). */
+    isConstant(name) {
+        return this.resolveName(name, 0) !== null;
     }
-    let pos = 0;
-    const peek = () => toks[pos];
-    const next = () => toks[pos++];
-    const FAIL = Symbol("expr-fail");
-    const fail = () => {
-      throw FAIL;
-    };
-    const grammar = this;
-    // Precedence climbing over the registry-declared infix tiers.
-    function parseExpr(minPrec) {
-      let lhs = parseOperand();
-      for (;;) {
-        const t = peek();
-        if (!t || t.kind !== "op") {
-          break;
-        }
-        const infix = grammar.infixTable.get(t.text);
-        if (!infix || infix.syntax.precedence < minPrec) {
-          break;
-        }
-        next();
-        const nextMin = infix.syntax.rightAssoc
-          ? infix.syntax.precedence
-          : infix.syntax.precedence + 1;
-        const rhs = parseExpr(nextMin);
-        lhs = grammar.applyScalar(infix.name, [lhs, rhs]);
-      }
-      return lhs;
+    /** Tokenize with this grammar's operator vocabulary. */
+    tokenize(s) {
+        return tokenize(s, this.operatorTokens);
     }
-    // An operand: a prefix operator (the arity-1 claimant of its symbol,
-    // binding up through the tightest infix tier), or an atom.
-    function parseOperand() {
-      const t = peek();
-      if (t && t.kind === "op") {
-        const prefix = grammar.prefixTable.get(t.text);
-        if (prefix === undefined) {
-          return fail();
-        }
-        next();
-        return grammar.applyScalar(prefix, [parseExpr(grammar.maxPrecedence)]);
-      }
-      return parseAtom();
+    /** The free-variable candidates of `s` under this grammar. */
+    freeVariables(s) {
+        return freeVariables(s, (n) => this.isFunction(n), (n) => this.isConstant(n));
     }
-    function parseAtom() {
-      const t = peek();
-      if (!t) {
-        fail();
-      }
-      if (t.kind === "num") {
-        next();
-        return t.value;
-      }
-      if (t.kind === "lparen") {
-        next();
-        const inner = parseExpr(0);
-        if (!peek() || peek().kind !== "rparen") {
-          fail();
+    /** Evaluate expression `s` with `variable` bound to `at`.  Returns a number,
+     *  or null if `s` is not a well-formed expression.  Every binary/function/
+     *  constant step is applied through the kernel, so the arithmetic is the
+     *  kernel's own.  When `variable` is empty, the single free variable is
+     *  auto-detected; if there is more than one and none was named, evaluation
+     *  declines (null) — a genuinely multivariate expression needs an explicit
+     *  binding. */
+    eval(s, variable, at) {
+        const toks = this.tokenize(s);
+        if (!toks || toks.length === 0)
+            return null;
+        let v = variable;
+        if (v === "") {
+            const fv = this.freeVariables(s);
+            if (fv.length === 1)
+                v = fv[0];
+            else if (fv.length > 1)
+                return null; // multivariate, no binding named
+            // fv.length === 0: a constant expression is fine.
+        }
+        let pos = 0;
+        const peek = () => toks[pos];
+        const next = () => toks[pos++];
+        const FAIL = Symbol("expr-fail");
+        const fail = () => {
+            throw FAIL;
+        };
+        const grammar = this;
+        // Precedence climbing over the registry-declared infix tiers.
+        function parseExpr(minPrec) {
+            let lhs = parseOperand();
+            for (;;) {
+                const t = peek();
+                if (!t || t.kind !== "op")
+                    break;
+                const infix = grammar.infixTable.get(t.text);
+                if (!infix || infix.syntax.precedence < minPrec)
+                    break;
+                next();
+                const nextMin = infix.syntax.rightAssoc
+                    ? infix.syntax.precedence
+                    : infix.syntax.precedence + 1;
+                const rhs = parseExpr(nextMin);
+                lhs = grammar.applyScalar(infix.name, [lhs, rhs]);
+            }
+            return lhs;
         }
-        next();
-        return inner;
-      }
-      if (t.kind === "name") {
-        next();
-        // A function call: name "(" expr ")".
-        if (peek() && peek().kind === "lparen") {
-          const fn = grammar.resolveName(t.text, 1);
-          if (fn === null) {
+        // An operand: a prefix operator (the arity-1 claimant of its symbol,
+        // binding up through the tightest infix tier), or an atom.
+        function parseOperand() {
+            const t = peek();
+            if (t && t.kind === "op") {
+                const prefix = grammar.prefixTable.get(t.text);
+                if (prefix === undefined)
+                    return fail();
+                next();
+                return grammar.applyScalar(prefix, [parseExpr(grammar.maxPrecedence)]);
+            }
+            return parseAtom();
+        }
+        function parseAtom() {
+            const t = peek();
+            if (!t)
+                fail();
+            if (t.kind === "num") {
+                next();
+                return t.value;
+            }
+            if (t.kind === "lparen") {
+                next();
+                const inner = parseExpr(0);
+                if (!peek() || peek().kind !== "rparen")
+                    fail();
+                next();
+                return inner;
+            }
+            if (t.kind === "name") {
+                next();
+                // A function call: name "(" expr ")".
+                if (peek() && peek().kind === "lparen") {
+                    const fn = grammar.resolveName(t.text, 1);
+                    if (fn === null)
+                        return fail();
+                    next(); // (
+                    const arg = parseExpr(0);
+                    if (!peek() || peek().kind !== "rparen")
+                        fail();
+                    next(); // )
+                    return grammar.applyScalar(fn, [arg]);
+                }
+                // Otherwise an identifier: the free variable, or a nullary constant
+                // resolved through the registry like any other operation.
+                if (t.text === v)
+                    return at;
+                const konst = grammar.resolveName(t.text, 0);
+                if (konst !== null)
+                    return grammar.applyScalar(konst, []);
+                return fail();
+            }
             return fail();
-          }
-          next(); // (
-          const arg = parseExpr(0);
-          if (!peek() || peek().kind !== "rparen") {
-            fail();
-          }
-          next(); // )
-          return grammar.applyScalar(fn, [arg]);
         }
-        // Otherwise an identifier: the free variable, or a nullary constant
-        // resolved through the registry like any other operation.
-        if (t.text === v) {
-          return at;
+        try {
+            const result = parseExpr(0);
+            if (pos !== toks.length)
+                return null; // trailing tokens → malformed
+            return Number.isFinite(result) ? result : null;
         }
-        const konst = grammar.resolveName(t.text, 0);
-        if (konst !== null) {
-          return grammar.applyScalar(konst, []);
+        catch (err) {
+            if (err === FAIL)
+                return null;
+            return null; // a kernel apply threw (e.g. ÷0 produced ∞) → decline
         }
-        return fail();
-      }
-      return fail();
-    }
-    try {
-      const result = parseExpr(0);
-      if (pos !== toks.length) {
-        return null; // trailing tokens → malformed
-      }
-      return Number.isFinite(result) ? result : null;
-    } catch (err) {
-      if (err === FAIL) {
-        return null;
-      }
-      return null; // a kernel apply threw (e.g. ÷0 produced ∞) → decline
     }
-  }
 }