@codehz/json-expr 0.3.0 → 0.5.0

package/README.md

@@ -6,12 +6,16 @@
 
 ## 特性
 
-- 🎯 **类型安全** - 使用 TypeScript 和 Zod 进行完整的类型推导和验证
+- 🎯 **类型安全** - 使用 TypeScript 泛型进行完整的编译时类型推导
 - 📦 **可序列化** - 编译后的表达式为纯 JSON 格式，易于传输和存储
 - 🔧 **灵活的表达式** - 支持任意 JavaScript 表达式，包括函数调用和对象属性访问
-- ⚡ **高性能** - 使用 `new Function()` 进行优化执行
+- ⚡ **高性能** - 优化的表达式编译和执行
 - 🧩 **可组合** - 表达式可以相互组合，形成复杂的计算树
-- 🔐 **类型验证** - 运行时通过 Zod schema 进行数据验证
+- 🔄 **短路求值** - 支持 `&&`、`||`、`??` 和三元表达式的控制流优化
+- 📝 **内联优化** - 自动内联只被引用一次的子表达式
+- 🔗 **Proxy 变量系统** - 支持链式属性访问和方法调用，如 `config.timeout`、`user.profile.name`
+- 🎛️ **Lambda 表达式** - 类型安全的数组方法支持（map、filter、reduce 等）
+- 🛡️ **错误检测** - 编译时检测未定义变量和类型错误
 
 ## 快速开始
 
@@ -24,12 +28,11 @@ bun install @codehz/json-expr
 ### 基本用法
 
 ```typescript
-import { z } from "zod";
-import { variable, expr, compile, evaluate, constant } from "@codehz/json-expr";
+import { variable, expr, compile, evaluate, t, lambda } from "@codehz/json-expr";
 
-// 定义类型化变量
-const x = variable(z.number());
-const y = variable(z.number());
+// 定义类型化变量（使用 TypeScript 泛型）
+const x = variable<number>();
+const y = variable<number>();
 
 // 构建表达式
 const sum = expr({ x, y })("x + y");
@@ -43,23 +46,29 @@ const compiled = compile(result, { x, y });
 // 执行编译后的表达式
 const value = evaluate(compiled, { x: 2, y: 3 });
 // => 11  (2+3 + 2*3 = 5 + 6 = 11)
+
+// 使用模板字符串
+const name = variable<string>();
+const greeting = t`Hello, ${name}!`;
+
+// 使用 lambda 表达式
+const numbers = variable<number[]>();
+const doubled = numbers.map(lambda<[number], number>((n) => expr({ n })("n * 2")));
 ```
 
 ## 核心概念
 
 ### Variable（变量）
 
-变量是表达式中的占位符，通过 Zod schema 定义其类型和验证规则。
+变量是表达式中的占位符，使用 TypeScript 泛型定义其类型。
 
 ```typescript
-const age = variable(z.number().int().min(0).max(150));
-const name = variable(z.string().min(1));
-const config = variable(
-  z.object({
-    debug: z.boolean(),
-    timeout: z.number(),
-  })
-);
+const age = variable<number>();
+const name = variable<string>();
+const config = variable<{
+  debug: boolean;
+  timeout: number;
+}>();
 ```
 
 ### Expression（表达式）
@@ -67,8 +76,8 @@ const config = variable(
 表达式对变量或其他表达式进行运算，使用字符串形式描述。
 
 ```typescript
-const x = variable(z.number());
-const y = variable(z.number());
+const x = variable<number>();
+const y = variable<number>();
 
 // 简单表达式
 const sum = expr({ x, y })("x + y");
@@ -93,51 +102,23 @@ const compiled = compile(result, { x, y });
 
 ## API 参考
 
-### `constant<T>(value: T): Expression<{}, T>`
-
-创建一个编译期常量表达式。这是 `expr({})(JSON.stringify(value))` 的快速路径，用于在表达式中嵌入静态值，避免在运行时传入或在多处重复编写。
-
-**参数：**
-
-- `value` - 要嵌入的常量值（必须是 JSON 可序列化的：string、number、boolean、null、数组或对象）
-
-**返回值：** Expression 对象
-
-**示例：**
-
-```typescript
-import { constant, expr, variable, compile, evaluate } from "@codehz/json-expr";
-import { z } from "zod";
-
-// 创建常量
-const PI = constant(3.14159);
-const config = constant({ maxRetries: 3, timeout: 5000 });
-
-// 在表达式中使用常量
-const radius = variable(z.number());
-const area = expr({ PI, radius })("PI * radius * radius");
-
-const compiled = compile(area, { radius });
-const result = evaluate(compiled, { radius: 2 });
-// => 12.56636
-```
-
-### `variable<T>(schema: T): Variable<T>`
+### `variable<T>(): Variable<T>`
 
 创建一个类型化变量。
 
-**参数：**
-
-- `schema` - Zod schema，定义变量的类型和验证规则
+**参数：** 无（类型通过泛型参数 `T` 指定）
 
-**返回值：** Variable 对象
+**返回值：** Variable 对象，支持属性访问和方法调用
 
 **示例：**
 
 ```typescript
-const num = variable(z.number());
-const str = variable(z.string());
-const date = variable(z.date());
+const num = variable<number>();
+const str = variable<string>();
+const config = variable<{ timeout: number }>();
+
+// 支持链式属性访问
+const timeout = config.timeout; // 自动转换为表达式
 ```
 
 ### `expr<TContext>(context: TContext): (source: string) => Expression<TContext, TResult>`
@@ -153,21 +134,21 @@ const date = variable(z.date());
 **示例：**
 
 ```typescript
-const x = variable(z.number());
-const y = variable(z.number());
+const x = variable<number>();
+const y = variable<number>();
 
 const sum = expr({ x, y })("x + y");
 const result = expr({ sum, x })("sum * x");
 ```
 
-### `compile<TResult>(expression: Expression<any, TResult>, variables: Record<string, Variable<any>>, options?: CompileOptions): CompiledData`
+### `compile<TResult>(expression: Expression<any, TResult>, variables: Record<string, Variable<any>> | Variable<any>[], options?: CompileOptions): CompiledData`
 
 将表达式树编译为可序列化的 JSON 结构。
 
 **参数：**
 
 - `expression` - 要编译的表达式
-- `variables` - 表达式中使用的所有变量映射
+- `variables` - 表达式中使用的所有变量映射或数组
 - `options` - 编译选项（可选）
   - `inline?: boolean` - 是否启用内联优化，将只被引用一次的子表达式内联到使用位置（默认：true）
   - `shortCircuit?: boolean` - 是否启用短路求值，为 &&, ||, ??, 和三元表达式生成控制流节点（默认：true）
@@ -177,14 +158,14 @@ const result = expr({ sum, x })("sum * x");
 **示例：**
 
 ```typescript
-const x = variable(z.number());
-const y = variable(z.number());
+const x = variable<number>();
+const y = variable<number>();
 const sum = expr({ x, y })("x + y");
 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 });
@@ -209,30 +190,222 @@ const noShortCircuit = compile(result, { x, y }, { shortCircuit: false });
 **示例：**
 
 ```typescript
+const x = variable<number>();
+const y = variable<number>();
+const sum = expr({ x, y })("x + y");
+const product = expr({ x, y })("x * y");
+const result = expr({ sum, product })("sum + product");
+
 const compiled = compile(result, { x, y });
 const value = evaluate(compiled, { x: 5, y: 3 });
 // => 23  ((5+3) + (5*3) = 8 + 15 = 23)
 ```
 
+### `t(strings: TemplateStringsArray, ...values: unknown[]): Proxify<string>`
+
+使用标签模板函数创建包含变量的字符串表达式。
+
+**参数：**
+
+- `strings` - 模板字符串的静态部分
+- `values` - 模板中插值的变量和表达式
+
+**返回值：** 字符串类型的 Proxy Expression
+
+**示例：**
+
+```typescript
+const name = variable<string>();
+const count = variable<number>();
+
+const greeting = t`Hello, ${name}!`;
+const message = t`You have ${count} items.`;
+
+const compiled = compile(greeting, { name });
+const result = evaluate(compiled, { name: "Alice" });
+// => "Hello, Alice!"
+```
+
+### `lambda<Args, R>(builder: LambdaBuilder<Args, R>): Lambda<Args, R>`
+
+创建类型安全的 lambda 表达式，用于数组方法（map、filter、reduce 等）。
+
+**参数：**
+
+- `builder` - Lambda 构建函数，接收参数代理，返回函数体表达式
+
+**返回值：** Lambda 表达式，可在数组方法中使用
+
+**示例：**
+
+```typescript
+import { lambda } from "@codehz/json-expr";
+
+// 单参数 lambda
+const numbers = variable<number[]>();
+const doubled = numbers.map(lambda<[number], number>((n) => expr({ n })("n * 2")));
+
+const compiled = compile(doubled, { numbers });
+const result = evaluate(compiled, { numbers: [1, 2, 3] });
+// => [2, 4, 6]
+
+// 多参数 lambda（reduce）
+const sum = numbers.reduce(
+  lambda<[number, number], number>((acc, val) => expr({ acc, val })("acc + val")),
+  0
+);
+
+// 捕获外部变量
+const multiplier = variable<number>();
+const scaled = numbers.map(lambda<[number], number>((n) => expr({ n, multiplier })("n * multiplier")));
+```
+
 ## 高级用法
 
-### 传入对象和内置对象
+### Proxy 变量系统
+
+`variable()` 创建的变量是 Proxy 对象，支持链式属性访问和方法调用，所有操作都会自动转换为表达式。
+
+**属性访问：**
+
+```typescript
+const config = variable<{
+  timeout: number;
+  retries: number;
+  database: {
+    host: string;
+    port: number;
+  };
+}>();
+
+// 链式属性访问
+const timeout = config.timeout; // 自动转换为表达式
+const dbHost = config.database.host; // 支持嵌套访问
+
+const compiled = compile(timeout, { config });
+const result = evaluate(compiled, {
+  config: { timeout: 5000, retries: 3, database: { host: "localhost", port: 5432 } },
+});
+// => 5000
+```
+
+**方法调用：**
+
+```typescript
+const calculator = variable<{
+  add(a: number, b: number): number;
+  multiply(x: number, y: number): number;
+}>();
+
+// 方法调用
+const sum = calculator.add(1, 2);
+const product = calculator.multiply(5, 3);
+
+// 链式方法调用
+const builder = variable<{
+  setName(name: string): typeof builder;
+  build(): { name: string };
+}>();
+const result = builder.setName("test").build();
+
+// 编译并执行
+const compiled = compile(sum, { calculator });
+const value = evaluate(compiled, {
+  calculator: {
+    add: (a, b) => a + b,
+    multiply: (x, y) => x * y,
+  },
+});
+// => 3
+```
+
+**数组方法：**
+
+数组变量支持所有标准数组方法，并自动处理类型推导：
+
+```typescript
+const numbers = variable<number[]>();
+const users = variable<{ id: number; name: string }[]>();
+
+// map
+const doubled = numbers.map((n) => expr({ n })("n * 2"));
+
+// filter
+const activeUsers = users.filter((u) => expr({ u })("u.active"));
 
-支持在上下文中传入对象（如 Math）以在表达式中访问其属性和方法：
+// reduce
+const sum = numbers.reduce(
+  lambda<[number, number], number>((acc, val) => expr({ acc, val })("acc + val")),
+  0
+);
+
+// find, some, every, sort 等
+const firstMatch = users.find((u) => expr({ u })("u.id === 1"));
+const hasAdmins = users.some((u) => expr({ u })("u.role === 'admin'"));
+const allActive = users.every((u) => expr({ u })("u.active"));
+const sorted = numbers.toSorted(lambda<[number, number], number>((a, b) => expr({ a, b })("a - b")));
+```
+
+### 内置全局对象
+
+表达式中可以直接使用以下内置对象（无需在上下文中定义）：
+
+- `Math`, `JSON`, `Date`, `RegExp`
+- `Number`, `String`, `Boolean`, `Array`, `Object`
+- `undefined`, `NaN`, `Infinity`
+- `isNaN`, `isFinite`, `parseInt`, `parseFloat`
 
 ```typescript
-const x = variable(z.number());
+const x = variable<number>();
 
-const sqrtExpr = expr({ x, Math: variable(z.any()) })("Math.sqrt(x)");
-const compiled = compile(sqrtExpr, { x, Math: variable(z.any()) });
-const result = evaluate(compiled, { x: 16, Math });
+const sqrtExpr = expr({ x })("Math.sqrt(x)");
+const compiled = compile(sqrtExpr, { x });
+const result = evaluate(compiled, { x: 16 });
 // => 4
 ```
 
+### 支持的运算符和语法
+
+**算术运算符：**
+
+- `+`, `-`, `*`, `/`, `%`, `**` (幂运算)
+
+**比较运算符：**
+
+- `==`, `===`, `!=`, `!==`, `<`, `>`, `<=`, `>=`
+
+**逻辑运算符：**
+
+- `&&`, `||`, `!`, `??` (空值合并)
+
+**位运算符：**
+
+- `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
+
+**其他运算符：**
+
+- `? :` (三元表达式)
+- `in` (属性存在检查)
+- `instanceof` (类型检查)
+- `typeof` (类型检测)
+- `?.` (可选链)
+- `?.()` (可选调用)
+- `?.[]` (可选元素访问)
+
+**语法特性：**
+
+- 对象字面量：`{ key: value, ... }`
+- 数组字面量：`[element1, element2, ...]`
+- 箭头函数：`(param) => expression`
+- 函数调用：`func(arg1, arg2, ...)`
+- 成员访问：`obj.prop`, `obj["prop"]`, `arr[0]`
+- 模板字面量（通过 `t` 标签函数）
+- 分组括号：`(expression)`
+
 ### 条件表达式
 
 ```typescript
-const score = variable(z.number());
+const score = variable<number>();
 const gradeExpr = expr({ score })("score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : 'F'");
 
 const compiled = compile(gradeExpr, { score });
@@ -243,7 +416,7 @@ const grade = evaluate(compiled, { score: 85 });
 ### 数组和对象操作
 
 ```typescript
-const numbers = variable(z.array(z.number()));
+const numbers = variable<number[]>();
 
 const sumExpr = expr({ numbers })("numbers.reduce((a, b) => a + b, 0)");
 
@@ -255,8 +428,8 @@ const sum = evaluate(compiled, { numbers: [1, 2, 3, 4, 5] });
 ### 链式表达式组合
 
 ```typescript
-const a = variable(z.number());
-const b = variable(z.number());
+const a = variable<number>();
+const b = variable<number>();
 
 const sum = expr({ a, b })("a + b");
 const product = expr({ a, b })("a * b");
@@ -269,6 +442,75 @@ const result = evaluate(compiled, { a: 2, b: 3 });
 // => (2+3) * (2*3) - (2-3) = 5 * 6 - (-1) = 30 + 1 = 31
 ```
 
+### 短路求值（控制流优化）
+
+编译器支持为 `&&`、`||`、`??` 和三元表达式生成短路求值代码，避免不必要的计算：
+
+```typescript
+const a = variable<boolean>();
+const b = variable<boolean>();
+
+// 逻辑或短路
+const orExpr = expr({ a, b })("a || b");
+const compiled = compile(orExpr, { a, b }, { shortCircuit: true });
+
+// 当 a 为 true 时，b 不会被求值
+// 编译数据包含控制流节点：
+// [["a", "b"], ["br", "$0", 1], "$1", ["phi"]]
+
+// 空值合并
+const x = variable<number | null>();
+const y = variable<number>();
+const coalesce = expr({ x, y })("x ?? y");
+
+// 三元表达式
+const condition = variable<boolean>();
+const result = variable<number>();
+const alternative = variable<number>();
+const ternary = expr({ condition, result, alternative })("condition ? result : alternative");
+```
+
+### 自动内联优化
+
+编译器自动将只被引用一次的子表达式内联到使用位置，减少中间计算：
+
+```typescript
+const x = variable<number>();
+const y = variable<number>();
+
+const sum = expr({ x, y })("x + y");
+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"]
+
+const compiled = compile(result, { x, y });
+const value = evaluate(compiled, { x: 2, y: 3 });
+// => 11
+```
+
+### 直接编译对象和数组
+
+`compile` 函数支持直接编译包含 Proxy 的对象和数组：
+
+```typescript
+const x = variable<number>();
+const y = variable<number>();
+const sum = expr({ x, y })("x + y");
+
+// 编译对象
+const objCompiled = compile({ result: sum, original: { x, y } }, { x, y });
+const objResult = evaluate(objCompiled, { x: 10, y: 20 });
+// => { result: 30, original: { x: 10, y: 20 } }
+
+// 编译数组
+const arrCompiled = compile([x, sum, 100], { x, y });
+const arrResult = evaluate(arrCompiled, { x: 5, y: 3 });
+// => [5, 8, 100]
+```
+
 ## 序列化和传输
 
 编译后的数据可以轻松进行 JSON 序列化，适合网络传输或持久化存储：
@@ -290,16 +532,200 @@ const deserialized = JSON.parse(json);
 const value = evaluate(deserialized, { x: 5, y: 3 });
 ```
 
+## 编译数据格式
+
+### V1 格式（基础表达式）
+
+基础格式为 JSON 数组：`[variableNames, ...expressions]`
+
+```typescript
+// 输入
+const sum = expr({ x, y })("x + y");
+const compiled = compile(sum, { x, y });
+
+// 输出
+// [["x", "y"], "$0+$1"]
+//  $0 引用 x，$1 引用 y
+```
+
+### V2 格式（控制流节点）
+
+启用短路求值时，生成包含控制流节点的格式：
+
+```typescript
+// 输入
+const result = expr({ a, b })("a || b");
+const compiled = compile(result, { a, b }, { shortCircuit: true });
+
+// 输出
+// [
+//   ["a", "b"],
+//   ["br", "$0", 1],  // 如果 $0 为 truthy，跳过 1 条指令
+//   "$1",             // 否则求值 $1
+//   ["phi"]           // 取最近求值结果
+// ]
+```
+
+**控制流节点类型：**
+
+- `["br", condition, offset]` - 条件跳转，条件为真时跳过 offset 条指令
+- `["jmp", offset]` - 无条件跳转，跳过 offset 条指令
+- `["phi"]` - 取最近求值结果（用于合并分支）
+
+## 错误处理
+
+### 编译时错误
+
+编译器会检测并报告以下错误：
+
+```typescript
+const x = variable<number>();
+const y = variable<number>();
+
+// 错误：引用未定义的变量
+const invalid = expr({ x, y })("x + y + z");
+compile(invalid, { x, y });
+// => Error: Undefined variable(s): z
+
+// 错误：变量名冲突
+const xy = variable<number>();
+const conflict = expr({ xy, x })("xy + x");
+// 正确处理：编译器能区分 xy 和 x
+const compiled = compile(conflict, { xy, x });
+// => [["xy", "x"], "$0+$1"]
+```
+
+### 运行时错误
+
+求值器会验证输入并报告运行时错误：
+
+```typescript
+const x = variable<number>();
+const y = variable<number>();
+
+const sum = expr({ x, y })("x + y");
+const compiled = compile(sum, { x, y });
+
+// 错误：缺少必需变量
+evaluate(compiled, { x: 2 });
+// => Error: Missing required variable: y
+
+// 错误：无效的编译数据
+evaluate([], { x: 1 });
+// => Error: Invalid compiled data: must have at least variable names
+```
+
 ## 类型安全
 
 项目充分利用 TypeScript 的类型系统进行编译时检查和类型推导：
 
 ```typescript
-const x = variable(z.number());
-const y = variable(z.string());
+const x = variable<number>();
+const y = variable<string>();
 
-// 提供完整的类型推导和自动补全
-const sum = expr({ x, y })("x + y");
+// 类型错误会在编译时捕获
+// const invalid = expr({ x, y })("z + y"); // Error: 'z' not in context
+const valid = expr({ x })("-x"); // 编译器推导为 number
+```
+
+## 实际应用示例
+
+### 动态表单验证规则
+
+```typescript
+const formData = variable<{
+  username: string;
+  password: string;
+  confirmPassword: string;
+  age: number;
+}>();
+
+// 创建验证规则表达式
+const isUsernameValid = expr({ formData })("formData.username.length >= 3 && formData.username.length <= 20");
+
+const isPasswordValid = expr({ formData })("formData.password.length >= 8 && /[A-Z]/.test(formData.password)");
+
+const doPasswordsMatch = expr({ formData })("formData.password === formData.confirmPassword");
+
+const isAgeValid = expr({ formData })("formData.age >= 18 && formData.age <= 120");
+
+const isFormValid = expr({
+  isUsernameValid,
+  isPasswordValid,
+  doPasswordsMatch,
+  isAgeValid,
+})("isUsernameValid && isPasswordValid && doPasswordsMatch && isAgeValid");
+
+// 编译一次，多次执行
+const compiled = compile(isFormValid, { formData });
+
+// 在表单输入时实时验证
+evaluate(compiled, {
+  formData: {
+    username: "john_doe",
+    password: "Secure123",
+    confirmPassword: "Secure123",
+    age: 25,
+  },
+}); // => true
+```
+
+### 数据转换管道
+
+```typescript
+const rawData = variable<any[]>();
+const config = variable<{
+  minValue: number;
+  maxValue: number;
+  transform: (x: number) => number;
+}>();
+
+// 构建数据处理管道
+const filtered = rawData.filter(
+  lambda<[any], boolean>((item) =>
+    expr({ item, config })("item.value >= config.minValue && item.value <= config.maxValue")
+  )
+);
+
+const transformed = filtered.map(
+  lambda<[any], number>((item) => expr({ item, config })("config.transform(item.value)"))
+);
+
+const sorted = transformed.toSorted(lambda<[number, number], number>((a, b) => expr({ a, b })("a - b")));
+
+const pipeline = compile(sorted, { rawData, config });
+
+// 执行数据处理
+const result = evaluate(pipeline, {
+  rawData: [{ value: 10 }, { value: 5 }, { value: 20 }, { value: 15 }],
+  config: { minValue: 8, maxValue: 18, transform: (x: number) => x * 2 },
+});
+// => [10, 20, 30] (5 被过滤，10*2=20, 15*2=30, 20 被过滤)
+```
+
+### 规则引擎
+
+```typescript
+// 定义规则条件
+const user = variable<{
+  age: number;
+  role: string;
+  balance: number;
+}>();
+
+const isEligible = expr({ user })(
+  "(user.age >= 18 && user.age <= 65) && (user.role === 'premium' || user.balance > 10000)"
+);
+
+const discountRate = expr({ user, isEligible })("isEligible ? (user.role === 'premium' ? 0.2 : 0.1) : 0");
+
+const rule = compile(discountRate, { user });
+
+// 应用规则
+const discount = evaluate(rule, {
+  user: { age: 30, role: "premium", balance: 5000 },
+});
+// => 0.2 (20% 折扣)
 ```
 
 ## 性能考虑
@@ -307,20 +733,45 @@ const sum = expr({ x, y })("x + y");
 - **编译时间**：编译过程涉及依赖分析和拓扑排序，通常快速完成
 - **执行时间**：表达式通过 `new Function()` 编译为原生 JavaScript，执行性能接近原生代码
 - **内存占用**：编译数据为纯 JSON，占用空间小，适合在网络上传输
+- **缓存机制**：求值器缓存已编译的函数，重复执行时性能更优
+
+### 最佳实践
+
+1. **编译一次，多次执行**：对于重复使用的表达式，先编译后多次求值
+
+   ```typescript
+   const compiled = compile(expression, variables);
+   // 缓存 compiled，多次调用 evaluate
+   evaluate(compiled, values1);
+   evaluate(compiled, values2);
+   ```
+
+2. **合理使用短路求值**：对于条件表达式，启用短路求值可以避免不必要的计算
+
+   ```typescript
+   compile(expression, variables, { shortCircuit: true });
+   ```
+
+3. **利用自动内联**：编译器会自动内联只引用一次的子表达式，无需手动优化
+
+4. **优先使用 Proxy 链式调用**：对于对象属性访问，使用 `config.timeout` 比 `expr({ config })("config.timeout")` 更简洁且类型更安全
 
 ## 项目结构
 
 ```
 src/
-├── index.ts              # 导出入口
-├── variable.ts           # variable 函数实现
-├── expr.ts               # expr 函数实现
-├── compile.ts            # compile 函数实现
-├── evaluate.ts           # evaluate 函数实现
-├── parser.ts             # 表达式解析器
-├── type-parser.ts        # 类型解析器
-├── types.ts              # 类型定义
-└── *.test.ts             # 测试文件
+├── index.ts          # 导出入口
+├── variable.ts       # variable<T>() 函数
+├── expr.ts           # expr() 函数
+├── template.ts       # t() 标签模板函数
+├── lambda.ts         # lambda() 函数（数组方法支持）
+├── compile.ts        # 编译器（内联优化、短路求值）
+├── evaluate.ts       # 运行时求值
+├── parser.ts         # 表达式 AST 解析器
+├── type-parser.ts    # TypeScript 类型级表达式解析
+├── proxy-variable.ts # Proxy 变量实现
+├── proxy-metadata.ts # Proxy 元数据管理
+└── types.ts          # 类型定义（Variable、Expression、Lambda 等）
 ```
 
 ## 开发