perf(core): precomputed ground flag (tau-prolog Term.apply) short-circuits applySubst/atomVars/occurs + shared leaf type arrays; oracle 62->39ms, 270/270

Author: MesTTo

packages/core/src/atom.test.ts

@@ -25,7 +25,7 @@ describe("atom constructors", () => {
     const atoms: Atom[] = [sym("a"), variable("x"), expr([]), gint(1)];
     for (const x of atoms) {
       expect(Object.keys(x).sort()).toEqual(
-        ["exec", "items", "kind", "match", "name", "typ", "value"].sort(),
+        ["exec", "ground", "items", "kind", "match", "name", "typ", "value"].sort(),
       );
     }
   });

packages/core/src/atom.ts

@@ -14,6 +14,7 @@ export interface SymAtom {
   readonly typ: undefined;
   readonly exec: undefined;
   readonly match: undefined;
+  readonly ground: true;
 }
 export interface VarAtom {
   readonly kind: "var";
@@ -23,6 +24,7 @@ export interface VarAtom {
   readonly typ: undefined;
   readonly exec: undefined;
   readonly match: undefined;
+  readonly ground: false;
 }
 export interface ExprAtom {
   readonly kind: "expr";
@@ -32,6 +34,9 @@ export interface ExprAtom {
   readonly typ: undefined;
   readonly exec: undefined;
   readonly match: undefined;
+  /** True iff no variable occurs anywhere inside (tau-prolog's `Term.ground`): lets `applySubst`,
+   *  `atomVars`, and `occurs` short-circuit instantly on closed terms. Computed once at construction. */
+  readonly ground: boolean;
 }
 /** A grounded value (LeaTTa `Ground`). Numbers track int vs float so `3` and `3.0` stay distinct. */
 export type Ground =
@@ -53,6 +58,7 @@ export interface GndAtom {
   readonly typ: Atom;
   readonly exec: GroundedExec | undefined;
   readonly match: GroundedMatch | undefined;
+  readonly ground: true;
 }
 export type Atom = SymAtom | VarAtom | ExprAtom | GndAtom;
 
@@ -95,6 +101,7 @@ export function sym(name: string): SymAtom {
       typ: undefined,
       exec: undefined,
       match: undefined,
+      ground: true,
     };
     SYM_INTERN.set(name, s);
   }
@@ -111,10 +118,17 @@ export function variable(name: string): VarAtom {
     typ: undefined,
     exec: undefined,
     match: undefined,
+    ground: false,
   };
 }
 
 export function expr(items: readonly Atom[]): ExprAtom {
+  let ground = true;
+  for (const it of items)
+    if (!it.ground) {
+      ground = false;
+      break;
+    }
   return {
     kind: "expr",
     name: undefined,
@@ -123,6 +137,7 @@ export function expr(items: readonly Atom[]): ExprAtom {
     typ: undefined,
     exec: undefined,
     match: undefined,
+    ground,
   };
 }
 
@@ -147,7 +162,7 @@ export function gnd(
   exec?: GroundedExec,
   match?: GroundedMatch,
 ): GndAtom {
-  return { kind: "gnd", name: undefined, items: undefined, value, typ, exec, match };
+  return { kind: "gnd", name: undefined, items: undefined, value, typ, exec, match, ground: true };
 }
 
 /** Grounded literal constructors. */
@@ -182,6 +197,7 @@ export function atomSize(a: Atom): number {
 
 /** All variable names occurring in an atom (LeaTTa `Atom.vars`), in first-seen order, deduped. */
 export function atomVars(a: Atom, out: string[] = []): string[] {
+  if (a.ground) return out; // closed term: no variables (tau-prolog ground short-circuit)
   switch (a.kind) {
     case "var":
       if (!out.includes(a.name)) out.push(a.name);

packages/core/src/eval.ts

@@ -401,22 +401,30 @@ function returnsAtom(env: MinEnv, a: Atom): boolean {
 // ---------- types ----------
 const headOr = (xs: readonly Atom[], d: Atom): Atom => (xs.length > 0 ? xs[0]! : d);
 const UNDEF = sym("%Undefined%");
+// Shared constant type-result arrays for the leaf cases: getTypes is on the hot path and these
+// results are read-only (callers index/headOr them, never mutate), so a fresh array per call is
+// pure allocation. (MORK-spirit: stop allocating on the hot path.)
+const NUMBER_T: Atom[] = [sym("Number")];
+const STRING_T: Atom[] = [sym("String")];
+const BOOL_T: Atom[] = [sym("Bool")];
+const GROUNDED_T: Atom[] = [sym("Grounded")];
+const UNDEF_T: Atom[] = [UNDEF];
 
 function getTypes(env: MinEnv, a: Atom): Atom[] {
   if (a.kind === "gnd") {
     const g = a.value;
-    if (g.g === "int" || g.g === "float") return [sym("Number")];
-    if (g.g === "str") return [sym("String")];
-    if (g.g === "bool") return [sym("Bool")];
-    return [sym("Grounded")];
+    if (g.g === "int" || g.g === "float") return NUMBER_T;
+    if (g.g === "str") return STRING_T;
+    if (g.g === "bool") return BOOL_T;
+    return GROUNDED_T;
   }
-  if (a.kind === "var") return [UNDEF];
+  if (a.kind === "var") return UNDEF_T;
   if (a.kind === "sym") {
     const ts = env.types.get(a.name);
-    return ts && ts.length > 0 ? ts : [UNDEF];
+    return ts && ts.length > 0 ? ts : UNDEF_T;
   }
   // expression
-  if (a.items.length === 0) return [UNDEF];
+  if (a.items.length === 0) return UNDEF_T;
   if (opOf(a) === "StateValue" && a.items.length === 2)
     return [expr([sym("StateMonad"), headOr(getTypes(env, a.items[1]!), UNDEF)])];
   const direct = env.exprTypes.filter((p) => atomEq(p[0], a));
@@ -441,7 +449,7 @@ function getTypes(env: MinEnv, a: Atom): Atom[] {
       out.push(instantiate(tb, ret));
     }
   }
-  return out.length > 0 ? out : [UNDEF];
+  return out.length > 0 ? out : UNDEF_T;
 }
 
 function matchReduced(tb: Bindings, expected: Atom, actual: Atom): Bindings | undefined {

packages/core/src/substitution.ts

@@ -25,6 +25,7 @@ export function extendSubst(s: Subst, x: string, a: Atom): Subst {
 /** Apply `s` to an atom: replace each variable by its assigned value (one pass; the substituted
  *  value is not itself re-substituted). */
 export function applySubst(s: Subst, a: Atom): Atom {
+  if (a.ground) return a; // closed term: substitution is identity, no walk (tau-prolog Term.apply)
   if (s.length === 0) return a; // empty substitution is identity (no clone)
   switch (a.kind) {
     case "var":
@@ -46,6 +47,7 @@ export function applySubst(s: Subst, a: Atom): Atom {
 
 /** Occurs-check: does `$x` appear anywhere in the atom? */
 export function occurs(x: string, a: Atom): boolean {
+  if (a.ground) return false; // closed term: no variable occurs in it
   switch (a.kind) {
     case "var":
       return x === a.name;