perf(core): interpreter stack as O(1) cons-list (no per-step array slice/spread); 270/270

Author: MesTTo

packages/core/src/eval.ts

@@ -17,7 +17,14 @@ export interface Frame {
   readonly vars: readonly string[];
   readonly fin: boolean;
 }
-export type Stack = readonly Frame[];
+// The evaluation stack as an immutable cons-list (O(1) push/rest, no per-step array slice/spread
+// — the array form showed up as ArrayPrototypeSlice in the profile). `null` is the empty stack.
+export interface StackCons {
+  readonly head: Frame;
+  readonly tail: Stack;
+}
+export type Stack = StackCons | null;
+const cons = (head: Frame, tail: Stack): StackCons => ({ head, tail });
 export interface Item {
   readonly stack: Stack;
   readonly bnd: Bindings;
@@ -80,7 +87,7 @@ function isEmbeddedOp(a: Atom): boolean {
   return op !== undefined && EMBEDDED.has(op);
 }
 
-const varsCopy = (prev: Stack): readonly string[] => (prev.length > 0 ? prev[0]!.vars : []);
+const varsCopy = (prev: Stack): readonly string[] => (prev !== null ? prev.head.vars : []);
 
 function isVariableHeaded(a: Atom): boolean {
   if (a.kind === "var") return true;
@@ -101,24 +108,24 @@ function atomToStack(a: Atom, prev: Stack): Stack {
     const op = opOf(a);
     const it = a.items;
     if (op === "chain" && it.length === 4 && it[2]!.kind === "var") {
-      return atomToStack(it[1]!, [frame(a, "chain", varsCopy(prev)), ...prev]);
+      return atomToStack(it[1]!, cons(frame(a, "chain", varsCopy(prev)), prev));
     }
     if (op === "function" && it.length === 2 && it[1]!.kind === "expr") {
-      return atomToStack(it[1]!, [frame(a, "function", varsCopy(prev)), ...prev]);
+      return atomToStack(it[1]!, cons(frame(a, "function", varsCopy(prev)), prev));
     }
     if (op === "unify" && it.length === 5) {
-      return [frame(a, "none"), ...prev];
+      return cons(frame(a, "none"), prev);
     }
-    if (op === "chain") return [frame(errAtom(a, "chain: malformed"), "none", [], true), ...prev];
+    if (op === "chain") return cons(frame(errAtom(a, "chain: malformed"), "none", [], true), prev);
     if (op === "function")
-      return [frame(errAtom(a, "function: malformed"), "none", [], true), ...prev];
-    if (op === "unify") return [frame(errAtom(a, "unify: malformed"), "none", [], true), ...prev];
+      return cons(frame(errAtom(a, "function: malformed"), "none", [], true), prev);
+    if (op === "unify") return cons(frame(errAtom(a, "unify: malformed"), "none", [], true), prev);
   }
-  return [frame(a, "none", varsCopy(prev)), ...prev];
+  return cons(frame(a, "none", varsCopy(prev)), prev);
 }
 
 function finItem(st: Stack, a: Atom, b: Bindings): Item {
-  return { stack: [frame(a, "none", [], true), ...st], bnd: b };
+  return { stack: cons(frame(a, "none", [], true), st), bnd: b };
 }
 
 function evalResult(prev: Stack, r: Atom, b: Bindings): Item {
@@ -338,16 +345,17 @@ function unifyOp(prev: Stack, a: Atom, p: Atom, t: Atom, e: Atom, b: Bindings):
 }
 
 // ---------- final-item helpers ----------
-const isFinal = (it: Item): boolean => it.stack.length === 1 && it.stack[0]!.fin;
+const isFinal = (it: Item): boolean =>
+  it.stack !== null && it.stack.tail === null && it.stack.head.fin;
 function finalPair(it: Item): [Atom, Bindings] {
-  const f = it.stack[0];
-  return f === undefined ? [emptyA, []] : [instantiate(it.bnd, f.atom), it.bnd];
+  const f = it.stack;
+  return f === null ? [emptyA, []] : [instantiate(it.bnd, f.head.atom), it.bnd];
 }
 function exhaustedPair(it: Item): [Atom, Bindings] {
-  const f = it.stack[0];
-  return f === undefined
+  const f = it.stack;
+  return f === null
     ? [emptyA, it.bnd]
-    : [expr([sym("Error"), instantiate(it.bnd, f.atom), sym("StackOverflow")]), it.bnd];
+    : [expr([sym("Error"), instantiate(it.bnd, f.head.atom), sym("StackOverflow")]), it.bnd];
 }
 
 function resolveAtomFix(b: Bindings, n: number, a: Atom): Atom {
@@ -372,8 +380,8 @@ function restrictBnd(vars: readonly string[], b: Bindings): Bindings {
 }
 function scopeVars(b: Bindings, prev: Stack): string[] {
   const out: string[] = [];
-  for (const f of prev)
-    for (const v of atomVars(instantiate(b, f.atom))) if (!out.includes(v)) out.push(v);
+  for (let p = prev; p !== null; p = p.tail)
+    for (const v of atomVars(instantiate(b, p.head.atom))) if (!out.includes(v)) out.push(v);
   return out;
 }
 function superposeItem(prev: Stack, b: Bindings, pair: Atom): Item {
@@ -604,29 +612,29 @@ function getDocOf(env: MinEnv, w: World, atom: Atom): Atom {
 
 // ---------- the step function ----------
 function interpretStack1(env: MinEnv, fuel: number, st: St, it: Item): [Item[], St] {
-  if (it.stack.length === 0) return [[], st];
-  const top = it.stack[0]!;
-  const prev = it.stack.slice(1);
+  if (it.stack === null) return [[], st];
+  const top = it.stack.head;
+  const prev = it.stack.tail;
   if (top.fin) {
-    if (prev.length === 0) return [[it], st];
-    const pf = prev[0]!;
-    const pprev = prev.slice(1);
+    if (prev === null) return [[it], st];
+    const pf = prev.head;
+    const pprev = prev.tail;
     const res = instantiate(it.bnd, top.atom);
     if (pf.ret === "chain") {
       if (opOf(pf.atom) === "chain" && pf.atom.kind === "expr" && pf.atom.items.length === 4) {
         const v = pf.atom.items[2]!;
         const templ = pf.atom.items[3]!;
         const nf = frame(expr([sym("chain"), res, v, templ]), pf.ret, pf.vars, false);
-        return [[{ stack: [nf, ...pprev], bnd: it.bnd }], st];
+        return [[{ stack: cons(nf, pprev), bnd: it.bnd }], st];
       }
       return [[finItem(pprev, errAtom(pf.atom, "chain: corrupt frame"), it.bnd)], st];
     }
     if (pf.ret === "function") {
       if (opOf(res) === "return" && res.kind === "expr" && res.items.length === 2)
         return [[finItem(pprev, res.items[1]!, it.bnd)], st];
       if (isEmbeddedOp(res))
-        return [[{ stack: atomToStack(res, [pf, ...pprev]), bnd: it.bnd }], st];
-      const target = pprev.length > 0 ? pprev[0]!.atom : res;
+        return [[{ stack: atomToStack(res, cons(pf, pprev)), bnd: it.bnd }], st];
+      const target = pprev !== null ? pprev.head.atom : res;
       return [[finItem(pprev, errAtom(target, "NoReturn"), it.bnd)], st];
     }
     return [[], st]; // Ret.none on a finished non-top frame
@@ -707,7 +715,7 @@ function interpretStack1(env: MinEnv, fuel: number, st: St, it: Item): [Item[],
     case "collapse-bind": {
       if (it2.length !== 2) break;
       const [atoms, st2] = interpretLoop(env, fuel, st, [
-        { stack: atomToStack(it2[1]!, []), bnd: it.bnd },
+        { stack: atomToStack(it2[1]!, null), bnd: it.bnd },
       ]);
       return [[finItem(prev, expr(atoms.map((p) => expr([p[0], unitA]))), it.bnd)], st2];
     }
@@ -816,7 +824,7 @@ function interpretStack1(env: MinEnv, fuel: number, st: St, it: Item): [Item[],
       break;
   }
   if (isEmbeddedOp(a)) return [[finItem(prev, errAtom(a, "unsupported minimal op"), it.bnd)], st];
-  return [[{ stack: [frame(top.atom, top.ret, top.vars, true), ...prev], bnd: it.bnd }], st];
+  return [[{ stack: cons(frame(top.atom, top.ret, top.vars, true), prev), bnd: it.bnd }], st];
 }
 
 // space-mutation helpers used by add/remove/import
@@ -1025,7 +1033,7 @@ function mettaEval(
       }
       const wApp = expr([sym(op), ...partAtoms]);
       const [pairs, st3] = interpretLoop(env, fuel, cur2, [
-        { stack: atomToStack(expr([sym("eval"), wApp]), []), bnd },
+        { stack: atomToStack(expr([sym("eval"), wApp]), null), bnd },
       ]);
       cur2 = st3;
       for (const p of pairs) {
@@ -1051,15 +1059,15 @@ function mettaEval(
   if (w.kind === "expr" && w.items.length > 0) {
     // expression-headed application
     const [ruleRes, st1] = interpretLoop(env, fuel, st, [
-      { stack: atomToStack(expr([sym("eval"), w]), []), bnd },
+      { stack: atomToStack(expr([sym("eval"), w]), null), bnd },
     ]);
     const reduced = ruleRes.filter((p) => !atomEq(p[0], w) && !atomEq(p[0], notReducibleA));
     if (reduced.length === 0) {
       const [tupleRes, st2] = interpretLoop(env, fuel, st1, [
         {
           stack: atomToStack(
             expr([sym("eval"), expr([sym("interpret-tuple"), w, sym("&self")])]),
-            [],
+            null,
           ),
           bnd,
         },
@@ -1088,7 +1096,7 @@ function mettaEval(
 
   // bare symbol / variable / grounded
   const [pairs, st1] = interpretLoop(env, fuel, st, [
-    { stack: atomToStack(expr([sym("eval"), w]), []), bnd },
+    { stack: atomToStack(expr([sym("eval"), w]), null), bnd },
   ]);
   const out: Array<[Atom, Bindings]> = [];
   let cur = st1;