递归宏 ​

核心概念 ​

递归宏是指在展开过程中调用自身的宏。由于 macro_rules! 没有循环结构,很多需要逐步处理参数列表的场景只能通过递归来实现。递归宏的工作方式类似于递归函数:定义一个基础情况(终止条件)和一个递归情况(将问题缩小后再次调用自身)。

Rust 编译器对宏递归有深度限制,默认最大递归深度为 128 层。可以用 #![recursion_limit = "256"] 属性来增加限制。递归宏在编译时展开,每次递归都会生成新的代码,然后编译器再对新代码中的宏调用进行展开,直到没有宏调用为止。

rust
// 递归宏的经典模式:逐个处理参数

// 计算参数个数
macro_rules! count {
    // 基础情况:没有参数,返回 0
    () => { 0 };
    // 递归情况:第一个参数 + 剩余参数的个数
    ($head:tt $($tail:tt)*) => {
        1 + count!($($tail)*)
    };
}

// 递归求最小值
macro_rules! min {
    // 基础情况:单个值
    ($x:expr) => { $x };
    // 递归情况:比较第一个和剩余的最小值
    ($x:expr, $($rest:expr),+) => {{
        let a = $x;
        let b = min!($($rest),+);
        if a < b { a } else { b }
    }};
}

fn main() {
    println!("count: {}", count!(a b c d e));  // 5
    println!("min: {}", min!(5, 3, 8, 1, 7));  // 1
}

递归模式分类 ​

rust
// === 1. 线性递归:每次消耗一个元素 ===
macro_rules! reverse_print {
    // 基础情况
    () => {};
    // 递归:先递归处理剩余,再打印当前
    ($head:expr $(, $tail:expr)*) => {
        reverse_print!($($tail),*);
        println!("{}", $head);
    };
}

// === 2. 累积递归:用额外参数收集中间结果 ===
macro_rules! join {
    // 入口:开始累积
    ($($item:expr),*) => {
        join!(@acc String::new(); $($item),*)
    };
    // 基础情况:返回累积结果
    (@acc $acc:expr;) => { $acc };
    // 递归:追加当前元素到累积器
    (@acc $acc:expr; $head:expr $(, $tail:expr)*) => {{
        let mut s = $acc;
        if !s.is_empty() {
            s.push_str(", ");
        }
        s.push_str(&format!("{}", $head));
        join!(@acc s; $($tail)*)
    }};
}

// === 3. 分治递归:将问题拆分为两半 ===
macro_rules! count_exprs {
    () => { 0 };
    ($single:expr) => { 1 };
    ($a:expr, $b:expr) => { 2 };
    ($a:expr, $b:expr, $($rest:expr),+) => {
        2 + count_exprs!($($rest),+)
    };
}

fn main() {
    println!("=== 线性递归 ===");
    reverse_print!(1, 2, 3);

    println!("\n=== 累积递归 ===");
    let s = join!("apple", "banana", "cherry");
    println!("{}", s);

    println!("\n=== 分治 ===");
    println!("count: {}", count_exprs!(1, 2, 3, 4, 5));
}

内部规则(tt muncher) ​

rust
// tt muncher(token 吞食者)是一种常见的递归宏模式
// 逐个消耗 token tree,对每个 token 做不同处理
// 通常用 @ 前缀的"内部规则"来区分不同的处理阶段

macro_rules! mixed_list {
    // 公开入口
    ($($items:tt)*) => {
        mixed_list!(@process [] $($items)*)
    };

    // 基础情况:所有 token 处理完毕
    (@process [$($collected:expr),*]) => {
        vec![$($collected),*]
    };

    // 匹配 key=value 形式
    (@process [$($collected:expr),*] $key:ident = $val:expr $(, $($rest:tt)*)?) => {
        mixed_list!(@process [$($collected,)* format!("{}={}", stringify!($key), $val)] $($($rest)*)?)
    };

    // 匹配普通表达式
    (@process [$($collected:expr),*] $item:expr $(, $($rest:tt)*)?) => {
        mixed_list!(@process [$($collected,)* format!("{}", $item)] $($($rest)*)?)
    };
}

// 带 @ 前缀的内部规则不会被外部调用
// 这是声明宏的惯用模式

macro_rules! state_machine {
    // 公开 API
    (start: $start:ident; $($rest:tt)*) => {
        state_machine!(@parse $start; $($rest)*)
    };
    // 内部:解析转移规则
    (@parse $current:ident; $state:ident -> $next:ident; $($rest:tt)*) => {
        println!("规则: {} → {}", stringify!($state), stringify!($next));
        state_machine!(@parse $current; $($rest)*)
    };
    // 内部:结束
    (@parse $current:ident;) => {
        println!("当前状态: {}", stringify!($current));
    };
}

fn main() {
    let items = mixed_list!(
        "hello",
        name = "Rust",
        42,
        debug = true
    );
    println!("{:?}", items);

    state_machine! {
        start: idle;
        idle -> running;
        running -> stopped;
        stopped -> idle;
    }
}

递归深度限制 ​

rust
// 默认递归深度限制为 128
// 可以通过 #![recursion_limit = "N"] 修改

// 如果递归过深,编译器会报错:
// error: recursion limit reached while expanding `my_macro!`

// 实用技巧:用对数级递归减少深度
// 例如:计数到 1024 只需要 10 层递归而不是 1024 层

macro_rules! count_to_n {
    // 单个元素
    (1) => { 1usize };
    // 偶数:拆成两半
    (2) => { 2usize };
    (4) => { count_to_n!(2) * 2 };
    (8) => { count_to_n!(4) * 2 };
    (16) => { count_to_n!(8) * 2 };
    (32) => { count_to_n!(16) * 2 };
    (64) => { count_to_n!(32) * 2 };
    (128) => { count_to_n!(64) * 2 };
    (256) => { count_to_n!(128) * 2 };
}

// 用重复替代递归来计数(不消耗递归深度)
macro_rules! count_args {
    ($($t:tt)*) => {
        <[()]>::len(&[$(count_args!(@replace $t ())),*])
    };
    (@replace $_t:tt $sub:expr) => { $sub };
}

fn main() {
    println!("count_to_n!(256) = {}", count_to_n!(256));
    println!("count_args = {}", count_args!(a b c d e f g h));
}

基本示例 ​

rust
// 递归宏实战:实现一个简单的表达式计算器

macro_rules! calc {
    // 基础情况:单个数字
    ($num:literal) => { $num as f64 };

    // 加法
    ($a:literal + $($rest:tt)+) => {
        calc!($a) + calc!($($rest)+)
    };

    // 减法
    ($a:literal - $($rest:tt)+) => {
        calc!($a) - calc!($($rest)+)
    };

    // 乘法(括号包裹优先级更高的运算)
    ($a:literal * $b:literal) => {
        calc!($a) * calc!($b)
    };

    // 除法
    ($a:literal / $b:literal) => {
        calc!($a) / calc!($b)
    };
}

// 递归宏实现链式比较
macro_rules! chain_cmp {
    ($a:expr, $b:expr) => {
        $a < $b
    };
    ($a:expr, $b:expr, $($rest:expr),+) => {
        $a < $b && chain_cmp!($b, $($rest),+)
    };
}

// 递归宏实现嵌套元组构建
macro_rules! nested_tuple {
    ($single:expr) => { $single };
    ($first:expr, $($rest:expr),+) => {
        ($first, nested_tuple!($($rest),+))
    };
}

// 递归宏实现 trait 的多类型批量实现
macro_rules! impl_display_for_nums {
    () => {};
    ($t:ty $(, $rest:ty)*) => {
        impl std::fmt::Display for Wrapper<$t> {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(f, "Wrapper({})", self.0)
            }
        }
        impl_display_for_nums!($($rest),*);
    };
}

#[derive(Debug)]
struct Wrapper<T>(T);

impl_display_for_nums!(i32, i64, f32, f64);

fn main() {
    // 计算器
    println!("10 + 5 = {}", calc!(10 + 5));
    println!("3 * 7 = {}", calc!(3 * 7));

    // 链式比较
    println!("1 < 2 < 3: {}", chain_cmp!(1, 2, 3));
    println!("1 < 2 < 2: {}", chain_cmp!(1, 2, 2));
    println!("1 < 3 < 5 < 8: {}", chain_cmp!(1, 3, 5, 8));

    // 嵌套元组
    let t = nested_tuple!(1, 2, 3, 4);
    println!("nested: {:?}", t);  // (1, (2, (3, 4)))

    // Wrapper Display
    println!("{}", Wrapper(42_i32));
    println!("{}", Wrapper(3.14_f64));
}

常见问题 ​

问题一:递归宏会影响运行时性能吗?

不会。宏递归完全在编译时完成,展开后就是普通的 Rust 代码。但递归层数过深会增加编译时间。

问题二:怎么避免递归过深?

用重复模式 $( ... )* 替代递归(不消耗递归深度),或者用对数级递归(每步减半而不是减一)。也可以增大 #![recursion_limit],但这只是治标不治本。

问题三:什么时候必须用递归而不能用重复?

当需要对参数列表做"逐步归约"处理时(如求最小值、反转、嵌套结构构建),重复模式无法表达这种逐步缩减的逻辑,必须用递归。

问题四:@ 前缀的内部规则是强制的吗?

不是强制的,但是惯用做法。@ 前缀可以防止用户意外调用内部规则,也让代码结构更清晰。任何不常见的 token 都可以用作前缀,但 @ 是社区约定。

适用场景 ​

  • 逐步归约:求最值、累加、连接等操作
  • 嵌套结构生成:递归构建嵌套元组或树结构
  • tt muncher:逐个消耗和处理异构 token
  • 多阶段处理:用内部规则实现状态机式的宏展开

注意事项 ​

  • 默认递归深度限制为 128 层
  • 必须有基础情况(终止条件),否则无限递归
  • 尽可能用重复模式替代递归以减少编译时间
  • 用 @ 前缀区分内部规则和公开 API
  • 递归宏的调试比较困难,用 cargo expand 查看展开结果

总结 ​

递归宏通过在展开过程中调用自身来实现逐步处理参数列表的逻辑。基本结构包括基础情况(终止条件)和递归情况(缩小问题后再次调用)。常见模式有线性递归(每次消耗一个元素)、累积递归(用额外参数收集结果)和 tt muncher(逐个消耗 token)。内部规则用 @ 前缀标识,避免被外部调用。默认递归深度限制为 128 层,可以通过 #![recursion_limit] 调整。能用重复模式 $( ... )* 解决的场景应优先使用重复而不是递归,因为重复不消耗递归深度且编译更快。