「宏系统与元编程」

# 模拟 C 风格文本宏: 纯字符串替换
def text_macro_expand(code, macros):
    for name, replacement in macros.items():
        code = code.replace(name, replacement)
    return code

code = "x = MAX(a, b) + MAX(a, b)"
macros = {"MAX(a, b)": "((a) > (b) ? (a) : (b))"}
print(text_macro_expand(code, macros))

# 迷你宏展开器: AST 上的模式替换
class Macro:
    def __init__(self, name, pattern, body):
        self.name, self.pattern, self.body = name, pattern, body

def expand(ast, macros, depth=0):
    if depth > 10:
        raise RecursionError("宏展开超过深度上限")
    if isinstance(ast, list):
        return [expand(x, macros, depth + 1) for x in ast]
    if isinstance(ast, tuple) and ast[0] == "macro":
        name, args = ast[1], ast[2:]
        m = macros.get(name)
        if m:
            body = m.body
            for i, p in enumerate(m.pattern):
                body = body.replace(p, str(args[i]))
            return expand(eval(body), macros, depth + 1)  # 递归展开
    return ast

macros = {"iflet": Macro("iflet", ("$cond", "$then"),
                          "['if', $cond, $then]")}
ast = [("macro", "iflet", "1>0", "'yes'")]
print(expand(ast, macros))                # ['if', True, 'yes']

import itertools

_gensym_counter = itertools.count()       # 计数器在函数外, 每次调用递增

def gensym(prefix="__g"):
    """生成独一无二的名字, 防止宏内部名字捕获调用点变量."""
    return f"{prefix}{next(_gensym_counter)}"

def swap_macro_body():
    tmp = gensym("__tmp")                 # 每次展开都是新名字
    return f"""
    {tmp} = a; a = b; b = {tmp};
    """.strip()

print("第一次展开:", swap_macro_body())
print("第二次展开:", swap_macro_body())   # 名字不同, 不冲突

class ConstEvaluator:
    """迷你编译期求值器: 只处理常量表达式."""
    def __init__(self): self.env = {}
    def eval(self, node):
        if isinstance(node, int):
            return node
        if isinstance(node, str) and node in self.env:
            return self.env[node]
        if isinstance(node, tuple):
            op, a, b = node
            return {
                "+": lambda: self.eval(a) + self.eval(b),
                "*": lambda: self.eval(a) * self.eval(b),
                "pow": lambda: self.eval(a) ** self.eval(b),
            }[op]()
        raise TypeError(f"非常量表达式: {node}")

ce = ConstEvaluator()
print("编译期 2^10 =", ce.eval(("pow", 2, 10)))
print("编译期 (3+4)*2 =", ce.eval(("*", ("+", 3, 4), 2)))

# const fn 的检查: 参数必须编译期可知
def is_const_compatible(param):
    return param in {"int", "bool", "str"}

def check_const_fn(fn_sig):
    ok = all(is_const_compatible(p) for p in fn_sig["params"])
    return "允许 const fn" if ok else "存在非常量参数"

print(check_const_fn({"params": ["int", "bool"]}))
print(check_const_fn({"params": ["int", "Vec<i32>"]}))

# 用 Python 模拟过程宏的 token 流变换
def derive_serialize(struct_def):
    """把 struct 定义改写成带 serialize 实现的代码."""
    name = struct_def["name"]
    fields = struct_def["fields"]
    body = "\n".join(
        f'  output += format!("\\"{k}\\":{{}}", self.{k});'
        for k in fields
    )
    return f"""
impl Serialize for {name} {{
  fn to_string(&self) -> String {{
    let mut output = String::from("{{");
    {body}
    output.push('}}');
    output
  }}
}}
"""

s = derive_serialize({"name": "Point", "fields": ["x", "y"]})
print(s)

# 属性宏: 改写函数签名
def route_attribute(route_path, fn_code):
    return (f"// 注册 {route_path} 到路由表\n" +
            fn_code.replace("async fn", "pub async fn"))

print(route_attribute("/users", "async fn list_users() {}"))

# 用宏思想实现一个内部 DSL: 把领域声明翻译成代码
def build_table_dsl(spec):
    cols = []
    for name, typ, opts in spec["columns"]:
        nullable = "NULL" if opts.get("nullable") else "NOT NULL"
        cols.append(f"{name} {typ} {nullable}")
    ddl = f"CREATE TABLE {spec['name']} (\n  " + ",\n  ".join(cols) + "\n);"
    model = f"struct {spec['model']} {{ " + " ".join(
        f"{n}: {t}," for n, t, _ in spec["columns"]) + " }"
    return ddl, model

ddl, model = build_table_dsl({
    "name": "users", "model": "User",
    "columns": [("id", "INTEGER", {"nullable": False}),
                ("email", "TEXT", {"nullable": False})],
})
print(ddl)
print(model)

# 宏展开调试: 展开模式预览工具
def show_expansion(source, macros):
    expanded = source
    for name, body in macros.items():
        while name in expanded:
            expanded = expanded.replace(name, body)
    print("=== 原始代码 ===")
    print(source)
    print("=== 展开结果 ===")
    print(expanded)

show_expansion(
    "let s = VEC![1, 2, 3];",
    {"VEC![1, 2, 3]": "vec![1, 2, 3].into_iter().collect()"},
)