perf(core): fetch operator signature once in mettaEval (drops redundant per-result Map lookups); 270/270

Author: MesTTo

packages/core/src/eval.ts

@@ -381,8 +381,7 @@ function superposeItem(prev: Stack, b: Bindings, pair: Atom): Item {
   return finItem(prev, pair, b);
 }
 
-function argMask(env: MinEnv, op: string, arity: number): boolean[] {
-  const ts = env.sigs.get(op);
+function argMask(ts: Atom[] | undefined, arity: number): boolean[] {
   if (ts === undefined) return Array<boolean>(arity).fill(true);
   return Array.from({ length: arity }, (_, i) => {
     const t = ts[i];
@@ -980,7 +979,12 @@ function mettaEval(
       ];
     }
     const queryVars = args.flatMap((x) => atomVars(x));
-    const mask = argMask(env, op, args.length);
+    // Fetch this operator's signature once and reuse it (avoids repeated Map lookups across
+    // argMask + the per-result returnsAtom check in the reduce loop below).
+    const sig = env.sigs.get(op);
+    const opReturnsAtom =
+      sig !== undefined && sig.length > 0 && atomEq(sig[sig.length - 1]!, sym("Atom"));
+    const mask = argMask(sig, args.length);
     // (1) type-directed argument evaluation, binding-threaded
     let partials: Array<[Atom[], Bindings]> = [[[], []]];
     let cur = st;
@@ -1029,7 +1033,7 @@ function mettaEval(
         const pb = restrictBnd(queryVars, mergedPb.length > 0 ? mergedPb[0]! : p[1]);
         if (atomEq(p[0], notReducibleA) || atomEq(p[0], wApp)) {
           out.push([wApp, partB]);
-        } else if (returnsAtom(env, wApp) && !isEmbeddedOp(p[0])) {
+        } else if (opReturnsAtom && !isEmbeddedOp(p[0])) {
           out.push([p[0], pb]);
         } else {
           const [more, st4] = mettaEval(env, fuel - 1, cur2, pb, p[0]);