Repository navigation
Expand file tree
/
Copy pathlambda.ts
More file actions
178 lines (155 loc) · 5.18 KB
/
Copy pathlambda.ts
File metadata and controls
178 lines (155 loc) · 5.18 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
// lambda.ts
import { getProxyMetadata, setProxyMetadata } from "../proxy/proxy-metadata";
import {
collectDepsFromArgs,
createProxyExpressionWithAST,
createProxyVariable,
serializeArgumentToAST,
} from "../proxy/proxy-variable";
import type { Lambda, LambdaBuilder, Proxify } from "../types";
import type { ASTNode } from "../types/ast-types";
/**
* Lambda 参数计数器,用于生成唯一 ID
*/
let lambdaParamCounter = 0;
/**
* Lambda 参数到索引的映射
* 用于编译时确定参数位置
*/
const lambdaParamIndices = new WeakMap<object, number>();
/**
* 获取 lambda 参数的索引
*/
export function getLambdaParamIndex(param: unknown): number | undefined {
if ((typeof param !== "object" && typeof param !== "function") || param === null) {
return undefined;
}
return lambdaParamIndices.get(param);
}
/**
* 创建 lambda 参数代理
* 生成带特殊标记的 Proxy,用于在表达式中追踪参数
*
* @param index - 参数索引(0, 1, 2...)
* @returns Lambda 参数代理
*/
function createLambdaParam<T>(index: number): Proxify<T> {
// 使用带前缀的唯一 ID,避免与普通变量冲突
const id = Symbol(`lambda_param_${lambdaParamCounter++}_${index}`);
const proxy = createProxyVariable<T>(id);
// 记录参数索引
lambdaParamIndices.set(proxy, index);
return proxy;
}
/**
* 创建类型安全的 lambda 表达式
*
* @template Args - 参数类型元组
* @template R - 返回值类型
* @param builder - Lambda 构建函数,接收参数代理,返回函数体表达式
* @returns Lambda 表达式代理
*
* @example
* ```ts
* const add = lambda<[number, number], number>(
* (a, b) => expr({ a, b })("a + b")
* );
*
* const numbers = variable<number[]>();
* const sum = numbers.reduce(add, 0);
* ```
*/
export function lambda<Args extends unknown[], R>(builder: LambdaBuilder<Args, R>): Lambda<Args, R> {
// 1. 创建参数代理和符号映射
const paramCount = builder.length;
const { params, paramSymbols } = createLambdaParams(paramCount);
// 2. 调用 builder 获取函数体表达式
const bodyExpr = builder(...(params as Parameters<LambdaBuilder<Args, R>>));
// 3. 从 bodyExpr 中提取 AST 和依赖
const { bodyAst, bodyDeps } = extractBodyAstAndDeps(bodyExpr);
// 4. 构造完整的箭头函数 AST(参数名使用占位符,在代码生成时分配)
// 注意:不再在此处转换参数占位符,而是保持占位符到代码生成时统一分配唯一参数名
const arrowFunctionAst = createArrowFunctionAst(bodyAst, paramCount, paramSymbols);
// 5. 过滤掉 lambda 参数依赖,只保留外部闭包变量
const closureDeps = filterClosureDeps(bodyDeps, paramSymbols);
// 7. 返回包含 lambda AST 的 Proxy
const lambdaProxy = createProxyExpressionWithAST<(...args: Args) => R>(arrowFunctionAst, closureDeps);
// 8. 设置额外的 lambda 元数据(标记为 lambda 类型)
const existingMeta = getProxyMetadata(lambdaProxy);
if (existingMeta) {
setProxyMetadata(lambdaProxy, {
...existingMeta,
type: "expression", // 保持为 expression,但 AST 包含箭头函数
});
}
return lambdaProxy;
}
/**
* 创建 lambda 参数和符号映射
*/
function createLambdaParams(paramCount: number) {
const params: Proxify<unknown>[] = [];
const paramSymbols: symbol[] = [];
for (let i = 0; i < paramCount; i++) {
const param = createLambdaParam<unknown>(i);
params.push(param);
// 获取参数的 Symbol ID
const meta = getProxyMetadata(param);
if (meta?.rootVariable) {
paramSymbols.push(meta.rootVariable);
}
}
return { params, paramSymbols };
}
/**
* 从表达式中提取 AST 和依赖
*/
function extractBodyAstAndDeps(bodyExpr: unknown): { bodyAst: ASTNode; bodyDeps: Set<symbol> } {
const meta =
(typeof bodyExpr === "object" || typeof bodyExpr === "function") && bodyExpr !== null
? getProxyMetadata(bodyExpr)
: undefined;
if (meta?.ast) {
// Proxy 表达式:使用其 AST 和依赖
return {
bodyAst: meta.ast,
bodyDeps: meta.dependencies ?? new Set<symbol>(),
};
} else {
// 普通对象、数组或原始值:使用 serializeArgumentToAST 转换
// 并收集其中可能包含的 Proxy 变量依赖
const bodyDeps = new Set<symbol>();
collectDepsFromArgs([bodyExpr], bodyDeps);
return {
bodyAst: serializeArgumentToAST(bodyExpr),
bodyDeps,
};
}
}
/**
* 创建箭头函数 AST
* 使用 Placeholder 节点作为参数,在代码生成时再分配实际参数名
*/
function createArrowFunctionAst(bodyAst: ASTNode, paramCount: number, paramSymbols: symbol[]): ASTNode {
const paramPlaceholders = Array.from({ length: paramCount }, (_, i) => ({
type: "Placeholder" as const,
id: paramSymbols[i]!,
}));
return {
type: "ArrowFunctionExpr",
params: paramPlaceholders,
body: bodyAst,
};
}
/**
* 过滤掉 lambda 参数依赖,只保留外部闭包变量
*/
function filterClosureDeps(bodyDeps: Set<symbol>, paramSymbols: symbol[]): Set<symbol> {
const closureDeps = new Set<symbol>();
for (const dep of bodyDeps) {
if (!paramSymbols.includes(dep)) {
closureDeps.add(dep);
}
}
return closureDeps;
}