递归宏
核心概念
递归宏是指在展开过程中调用自身的宏。由于 macro_rules! 没有循环结构,很多需要逐步处理参数列表的场景只能通过递归来实现。递归宏的工作方式类似于递归函数:定义一个基础情况(终止条件)和一个递归情况(将问题缩小后再次调用自身)。
Rust 编译器对宏递归有深度限制,默认最大递归深度为 128 层。可以用 #![recursion_limit = "256"] 属性来增加限制。递归宏在编译时展开,每次递归都会生成新的代码,然后编译器再对新代码中的宏调用进行展开,直到没有宏调用为止。
// 递归宏的经典模式:逐个处理参数
// 计算参数个数
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
}递归模式分类
// === 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)
// 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;
}
}递归深度限制
// 默认递归深度限制为 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));
}基本示例
// 递归宏实战:实现一个简单的表达式计算器
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] 调整。能用重复模式 $( ... )* 解决的场景应优先使用重复而不是递归,因为重复不消耗递归深度且编译更快。