refactor: change variable reference format from $0 to $[0] and optimize evaluator

- Change variable reference format from $0, $1 to $[0], $[1] in compiled expressions
- Optimize evaluate.ts by removing intermediate variable declarations
- Update all tests and documentation to use new format
- Simplify code generation by directly using $ array for all operations

Author: codehz

README.md

@@ -41,7 +41,7 @@ const result = expr({ sum, product })("sum + product");
 
 // 编译表达式（可序列化为 JSON）
 const compiled = compile(result, { x, y });
-// => [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// => [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 // 执行编译后的表达式
 const value = evaluate(compiled, { x: 2, y: 3 });
@@ -102,7 +102,7 @@ const array = expr({ x, y })("[x, y].filter(v => v > 0)");
 // 其中 $N 用于引用之前的变量或表达式
 
 const compiled = compile(result, { x, y });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 ```
 
 ## API 参考
@@ -169,11 +169,11 @@ const product = expr({ x, y })("x * y");
 const result = expr({ sum, product })("sum + product");
 
 const compiled = compile(result, { x, y });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 // 禁用内联优化
 const noInline = compile(result, { x, y }, { inline: false });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 ```
 
 ### `evaluate<TResult>(data: CompiledData, values: Record<string, unknown>): TResult`
@@ -600,7 +600,7 @@ const compiled = compile(orExpr, { a, b });
 
 // 当 a 为 true 时，b 不会被求值
 // 编译数据包含控制流节点：
-// [["a", "b"], ["br", "$0", 1], "$1", ["phi"]]
+// [["a", "b"], ["br", "$[0]", 1], "$[1]", ["phi"]]
 
 // 空值合并
 const x = variable<number | null>();
@@ -627,8 +627,8 @@ const product = expr({ x, y })("x * y");
 const result = expr({ sum, product })("sum + product");
 
 // 自动内联后，编译结果为：
-// [["x", "y"], "($0+$1)+($0*$1)"]
-// 而不是 [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "($[0]+$[1])+($[0]*$[1])"]
+// 而不是 [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 const compiled = compile(result, { x, y });
 const value = evaluate(compiled, { x: 2, y: 3 });
@@ -665,7 +665,7 @@ const compiled = compile(result, { x, y });
 
 // 序列化
 const json = JSON.stringify(compiled);
-// "[["x","y"],"$0+$1","$0*$1","$2+$3"]"
+// "[["x","y"],"$[0]+$[1]","$[0]*$[1]","$[2]+$[3]"]"
 
 // 存储或传输...
 
@@ -688,8 +688,8 @@ const sum = expr({ x, y })("x + y");
 const compiled = compile(sum, { x, y });
 
 // 输出
-// [["x", "y"], "$0+$1"]
-//  $0 引用 x，$1 引用 y
+// [["x", "y"], "$[0]+$[1]"]
+//  $[0] 引用 x，$[1] 引用 y
 ```
 
 ### V2 格式（控制流节点）
@@ -704,8 +704,8 @@ const compiled = compile(result, { a, b });
 // 输出
 // [
 //   ["a", "b"],
-//   ["br", "$0", 1],  // 如果 $0 为 truthy，跳过 1 条指令
-//   "$1",             // 否则求值 $1
+//   ["br", "$[0]", 1],  // 如果 $[0] 为 truthy，跳过 1 条指令
+//   "$[1]",             // 否则求值 $[1]
 //   ["phi"]           // 取最近求值结果
 // ]
 ```
@@ -736,7 +736,7 @@ const xy = variable<number>();
 const conflict = expr({ xy, x })("xy + x");
 // 正确处理：编译器能区分 xy 和 x
 const compiled = compile(conflict, { xy, x });
-// => [["xy", "x"], "$0+$1"]
+// => [["xy", "x"], "$[0]+$[1]"]
 ```
 
 ### 运行时错误

src/compile.test.ts

@@ -22,8 +22,8 @@ describe("compile 单元测试", () => {
       const sum = expr({ x, y })("x + y");
       const result = compile(sum, { x, y });
 
-      // 变量被替换为 $0, $1 等
-      expect(result[1]).toBe("$0+$1");
+      // 变量被替换为 $[0], $[1] 等
+      expect(result[1]).toBe("$[0]+$[1]");
     });
 
     test("变量顺序与声明顺序一致", () => {
@@ -46,7 +46,7 @@ describe("compile 单元测试", () => {
       const result = compile(e, { xy, x });
 
       expect(result[0]).toEqual(["xy", "x"]);
-      expect(result[1]).toBe("$0+$1");
+      expect(result[1]).toBe("$[0]+$[1]");
     });
   });
 
@@ -90,7 +90,7 @@ describe("compile 单元测试", () => {
       const result = compile(e, { x, y });
 
       // 输出应该是规范化的
-      expect(result[1]).toBe("$0+$1*2");
+      expect(result[1]).toBe("$[0]+$[1]*2");
     });
 
     test("保留必要的括号", () => {
@@ -101,7 +101,7 @@ describe("compile 单元测试", () => {
       const result = compile(e, { x, y });
 
       // 括号应该被保留以保持正确的运算顺序
-      expect(result[1]).toBe("($0+$1)*2");
+      expect(result[1]).toBe("($[0]+$[1])*2");
     });
   });
 
@@ -114,23 +114,23 @@ describe("compile 单元测试", () => {
       const result = compile({ sum, x, constant: 1 }, { x, y });
 
       expect(result[0]).toEqual(["x", "y"]);
-      expect(result[1]).toBe("{sum:$0+$1,x:$0,constant:1}");
+      expect(result[1]).toBe("{sum:$[0]+$[1],x:$[0],constant:1}");
     });
 
     test("支持数组中包含 Proxy", () => {
       const x = variable<number[]>();
       const result = compile([x, x.at(0), 42], { x });
 
       expect(result[0]).toEqual(["x"]);
-      expect(result[1]).toBe("[$0,$0.at(0),42]");
+      expect(result[1]).toBe("[$[0],$[0].at(0),42]");
     });
 
     test("支持直接传入 root variable", () => {
       const x = variable<number>();
       const result = compile(x, { x });
 
       expect(result[0]).toEqual(["x"]);
-      expect(result[1]).toBe("$0");
+      expect(result[1]).toBe("$[0]");
     });
 
     test("支持原始值", () => {

src/compile.ts

@@ -64,7 +64,7 @@ export interface CompileOptions {}
  * const sum = expr({ x, y })("x + y")
  * const result = expr({ sum, x })("sum * x")
  * const compiled = compile(result, { x, y })
- * // => [["x", "y"], "($0+$1)*$0"]
+ * // => [["x", "y"], "($[0]+$[1])*$[0]"]
  * ```
  */
 export function compile<TResult>(
@@ -90,24 +90,24 @@ export function compile<TResult>(
     }
   }
 
-  // 第一步：转换 Placeholder 节点为 $N 格式的 Identifier
+  // 第一步：转换 Placeholder 节点为 $[N] 格式的 Identifier
   // lambda 参数的 Placeholder 保留不转换（返回 null）
   const placeholderTransformed = transformPlaceholders(ast, (id) => {
     const name = symbolToName.get(id);
     if (!name) return null; // 不是变量占位符（可能是 lambda 参数），保留
     const index = variableToIndex.get(name);
     if (index === undefined) return null;
-    return `$${index}`;
+    return `$[${index}]`;
   });
 
   // 第二步：检查是否有未定义的 Identifier（非全局对象）
   const undefinedVars: string[] = [];
   const transformed = transformIdentifiers(placeholderTransformed, (name) => {
-    // 已经转换为 $N 的跳过
-    if (name.startsWith("$") && /^\$\d+$/.test(name)) return name;
+    // 已经转换为 $[N] 的跳过
+    if (name.startsWith("$[") && /^\$\[\d+\]$/.test(name)) return name;
 
     const index = variableToIndex.get(name);
-    if (index !== undefined) return `$${index}`;
+    if (index !== undefined) return `$[${index}]`;
 
     if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
     return name;
@@ -138,9 +138,9 @@ export function compile<TResult>(
     const leftIdx = compileAst(node.left);
 
     const branchConditions: Record<string, string> = {
-      "||": `$${leftIdx}`,
-      "&&": `!$${leftIdx}`,
-      "??": `$${leftIdx}!=null`,
+      "||": `$[${leftIdx}]`,
+      "&&": `!$[${leftIdx}]`,
+      "??": `$[${leftIdx}]!=null`,
     };
 
     const branchIdx = expressions.length;
@@ -161,7 +161,7 @@ export function compile<TResult>(
     const testIdx = compileAst(node.test);
 
     const branchIdx = expressions.length;
-    expressions.push(["br", `$${testIdx}`, 0] as BranchNode);
+    expressions.push(["br", `$[${testIdx}]`, 0] as BranchNode);
     nextIndex++;
 
     compileAst(node.alternate);

src/evaluate.ts

@@ -37,16 +37,7 @@ function translateControlFlow(expressions: CompiledExpression[], variableCount:
     }
   }
 
-  const lines: string[] = [
-    // 初始化变量
-    ...Array.from({ length: variableCount }, (_, i) => `const $${i} = $values[${i}];`),
-    "let $lastValue;",
-  ];
-
-  // 预先声明所有中间变量
-  for (let i = 0; i < expressions.length; i++) {
-    lines.push(`let $${variableCount + i};`);
-  }
+  const lines: string[] = ["let $lastValue;"];
 
   // 追踪已处理过的指令索引
   const processed = new Set<number>();
@@ -66,8 +57,7 @@ function translateControlFlow(expressions: CompiledExpression[], variableCount:
       if (typeof expr === "string") {
         // 普通表达式
         processed.add(i);
-        lines.push(`${indent}$${varIdx} = $lastValue = ${expr};`);
-        lines.push(`${indent}$values[${varIdx}] = $${varIdx};`);
+        lines.push(`${indent}$[${varIdx}] = $lastValue = ${expr};`);
         i++;
       } else if (!Array.isArray(expr)) {
         i++;
@@ -119,8 +109,7 @@ function translateControlFlow(expressions: CompiledExpression[], variableCount:
         } else if (type === "phi") {
           // Phi 节点：取最近的值
           processed.add(i);
-          lines.push(`${indent}$${varIdx} = $lastValue;`);
-          lines.push(`${indent}$values[${varIdx}] = $${varIdx};`);
+          lines.push(`${indent}$[${varIdx}] = $lastValue;`);
           i++;
         } else if (type === "jmp") {
           // jmp 不应该单独出现，应该已被 br 处理
@@ -154,7 +143,7 @@ function translateControlFlow(expressions: CompiledExpression[], variableCount:
  *
  * @example
  * ```ts
- * const compiled = [["x", "y"], "$0+$1", "$1*2"]
+ * const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
  * const result = evaluate<number>(compiled, { x: 2, y: 3 })
  * // => 6  (3 * 2)
  * ```
@@ -194,7 +183,7 @@ export function evaluate<TResult = unknown>(data: CompiledData, values: Record<s
     // 默认使用 V2 格式的函数体构造器
     const functionBody = buildEvaluatorFunctionBodyV2(expressions, variableNames.length);
     // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    evaluator = new Function("$values", functionBody) as (values: unknown[]) => unknown;
+    evaluator = new Function("$", functionBody) as (values: unknown[]) => unknown;
     evaluatorCache.set(cacheKey, evaluator);
   }
 

src/integration.short-circuit.test.ts

@@ -406,12 +406,12 @@ describe("短路求值测试", () => {
       const result = expr({ a, b })("a || b");
       const compiled = compile(result, { a, b });
 
-      // 应该生成: $0, ["br", "$2", 1], $1, ["phi"]
-      // 偏移量为 1，因为只需跳过 $1 一条指令
+      // 应该生成: $[0], ["br", "$[2]", 1], $[1], ["phi"]
+      // 偏移量为 1，因为只需跳过 $[1] 一条指令
       expect(compiled[0]).toEqual(["a", "b"]);
-      expect(compiled[1]).toBe("$0"); // 左操作数
-      expect(compiled[2]).toEqual(["br", "$2", 1]); // 如果 $2 为 true，跳过 1 条
-      expect(compiled[3]).toBe("$1"); // 右操作数
+      expect(compiled[1]).toBe("$[0]"); // 左操作数
+      expect(compiled[2]).toEqual(["br", "$[2]", 1]); // 如果 $[2] 为 true，跳过 1 条
+      expect(compiled[3]).toBe("$[1]"); // 右操作数
       expect(compiled[4]).toEqual(["phi"]); // phi 节点
     });
 
@@ -423,9 +423,9 @@ describe("短路求值测试", () => {
       const compiled = compile(result, { a, b });
 
       expect(compiled[0]).toEqual(["a", "b"]);
-      expect(compiled[1]).toBe("$0");
-      expect(compiled[2]).toEqual(["br", "!$2", 1]); // 如果 !$2 为 true，跳过 1 条
-      expect(compiled[3]).toBe("$1");
+      expect(compiled[1]).toBe("$[0]");
+      expect(compiled[2]).toEqual(["br", "!$[2]", 1]); // 如果 !$[2] 为 true，跳过 1 条
+      expect(compiled[3]).toBe("$[1]");
       expect(compiled[4]).toEqual(["phi"]);
     });
 
@@ -437,9 +437,9 @@ describe("短路求值测试", () => {
       const compiled = compile(result, { a, b });
 
       expect(compiled[0]).toEqual(["a", "b"]);
-      expect(compiled[1]).toBe("$0");
-      expect(compiled[2]).toEqual(["br", "$2!=null", 1]); // 如果非 null，跳过 1 条
-      expect(compiled[3]).toBe("$1");
+      expect(compiled[1]).toBe("$[0]");
+      expect(compiled[2]).toEqual(["br", "$[2]!=null", 1]); // 如果非 null，跳过 1 条
+      expect(compiled[3]).toBe("$[1]");
       expect(compiled[4]).toEqual(["phi"]);
     });
 
@@ -451,9 +451,9 @@ describe("短路求值测试", () => {
       const result = expr({ cond, x, y })("cond ? x : y");
       const compiled = compile(result, { cond, x, y });
 
-      // 结构: $0 (cond), ["br", "$3", offset], $2 (else), ["jmp", offset], $1 (then), ["phi"]
+      // 结构: $[0] (cond), ["br", "$[3]", offset], $[2] (else), ["jmp", offset], $[1] (then), ["phi"]
       expect(compiled[0]).toEqual(["cond", "x", "y"]);
-      expect(compiled[1]).toBe("$0"); // 条件
+      expect(compiled[1]).toBe("$[0]"); // 条件
       expect(compiled[2]![0]).toBe("br"); // 条件跳转
       expect(compiled[4]![0]).toBe("jmp"); // 无条件跳转
       expect(compiled[compiled.length - 1]).toEqual(["phi"]); // phi 节点

src/lambda.test.ts

@@ -671,7 +671,7 @@ describe("嵌套 lambda", () => {
       );
 
       const compiled = compile(processed, { matrix });
-      // 编译结果: $0.map((_0,_1)=>_0.map(_2=>_2+_1*100))
+      // 编译结果: $[0].map((_0,_1)=>_0.map(_2=>_2+_1*100))
       expect(compiled[1]).toContain("(_0,_1)=>_0.map(_2=>");
 
       const result = evaluate(compiled, {

src/parser.test.ts

@@ -185,8 +185,8 @@ describe("parser 单元测试", () => {
     test("使用映射", () => {
       const ast = parse("a + b * 2");
       const mapping: Record<string, number> = { a: 0, b: 1 };
-      const transformed = transformIdentifiers(ast, (name) => (name in mapping ? `$${mapping[name]}` : name));
-      expect(generate(transformed)).toBe("$0+$1*2");
+      const transformed = transformIdentifiers(ast, (name) => (name in mapping ? `$[${mapping[name]}]` : name));
+      expect(generate(transformed)).toBe("$[0]+$[1]*2");
     });
 
     test("成员访问保留属性名", () => {