Rust 2026 经验谈 - 声明宏（macro_rules!）实战

1
macro_rules! compute_hash {
2
    // 基础情形：没有更多 token（$(,)? 处理递归产生的尾逗号）
3
    (@hash $acc:expr $(,)?) => {
4
        $acc
5
    };
6
    // 递归情形：吃掉一对 key:value，更新累加值
7
    (@hash $acc:expr, $key:tt => $value:expr $(, $rest:tt => $rest_value:expr)*) => {
8
        compute_hash!(@hash $acc ^ ($key as u64).wrapping_mul($value as u64), $($rest => $rest_value)*)
9
    };
10
    // 入口：初始化累加值
11
    ($($key:tt => $value:expr),* $(,)?) => {
12
        compute_hash!(@hash 0u64, $($key => $value),*)
13
    };
14
}
15

16
let h = compute_hash!(1 => 100, 2 => 200, 3 => 300);
17
// 展开过程：
18
// compute_hash!(@hash 0, 1 => 100, 2 => 200, 3 => 300)
19
// compute_hash!(@hash 0 ^ 1*100, 2 => 200, 3 => 300)
20
// compute_hash!(@hash (0 ^ 1*100) ^ 2*200, 3 => 300)
21
// compute_hash!(@hash ((0 ^ 1*100) ^ 2*200) ^ 3*300)
22
// => 最终表达式

1
macro_rules! hashmap {
2
    (@single $key:expr => $value:expr) => {
3
        ($key, $value)
4
    };
5
    (@multiple $map:expr, $key:expr => $value:expr $(, $rest_k:expr => $rest_v:expr)*) => {
6
        {
7
            $map.insert($key, $value);
8
            hashmap!(@multiple $map, $($rest_k => $rest_v),*)
9
        }
10
    };
11
    (@multiple $map:expr $(,)?) => {
12
        $map
13
    };
14
    ($($key:expr => $value:expr),* $(,)?) => {
15
        {
16
            let mut map = std::collections::HashMap::new();
17
            hashmap!(@multiple map, $($key => $value),*)
18
        }
19
    };
20
}
21

22
let m = hashmap! {
23
    "a" => 1,
24
    "b" => 2,
25
    "c" => 3,
26
};
27
assert_eq!(m["a"], 1);

1
macro_rules! idents_to_strings {
2
    // 入口：启动递归，初始化累加器
3
    ($($id:ident),* $(,)?) => {
4
        idents_to_strings!(@acc [], $($id),*)
5
    };
6
    // 递归：吃掉一个 ident，push 到累加器
7
    (@acc [$($acc:expr),*], $id:ident $(, $rest:ident)*) => {
8
        idents_to_strings!(@acc [$($acc,)* stringify!($id)], $($rest),*)
9
    };
10
    // 基础：没有更多 ident，输出累加器
11
    (@acc [$($acc:expr),*],) => {
12
        [$($acc),*]
13
    };
14
    // 基础：只有一个 ident（无尾逗号）
15
    (@acc [$($acc:expr),*], $id:ident) => {
16
        [$($acc,)* stringify!($id)]
17
    };
18
}
19

20
let names = idents_to_strings!(foo, bar, baz);
21
assert_eq!(names, ["foo", "bar", "baz"]);

1
macro_rules! make_getters {
2
    (@acc [$($acc:item)*], $field:ident : $ty:ty $(, $rest:ident : $rest_ty:ty)*) => {
3
        make_getters!(@acc [
4
            $($acc)*
5
            pub fn $field(&self) -> &$ty {
6
                &self.$field
7
            }
8
        ], $($rest : $rest_ty),*)
9
    };
10
    (@acc [$($acc:item)*],) => {
11
        $($acc)*
12
    };
13
    (@acc [$($acc:item)*], $field:ident : $ty:ty) => {
14
        $($acc)*
15
        pub fn $field(&self) -> &$ty {
16
            &self.$field
17
        }
18
    };
19
    ($($field:ident : $ty:ty),* $(,)?) => {
20
        make_getters!(@acc [], $($field : $ty),*)
21
    };
22
}
23

24
struct Point {
25
    x: f64,
26
    y: f64,
27
    z: f64,
28
}
29

30
impl Point {
31
    make_getters!(x: f64, y: f64, z: f64);
32
}
33

34
let p = Point { x: 1.0, y: 2.0, z: 3.0 };
35
assert_eq!(p.x(), &1.0);

1
macro_rules! repeat_demo {
2
    // $()* ——重复零次或多次
3
    // $()+ ——重复一次或多次
4
    // $()? ——重复零次或一次
5
    // 分隔符：,$()* ——用逗号分隔
6

7
    // 零或多次，逗号分隔，可选尾逗号
8
    ($($elem:expr),* $(,)?) => {
9
        vec![$($elem),*]
10
    };
11
}
12

13
let v = repeat_demo!(1, 2, 3);
14
let v2 = repeat_demo!(1, 2, 3,);  // 尾逗号也行
15
let v3 = repeat_demo!();           // 空也行

1
// 模式 1：key-value 对
2
// $(key => value),*
3
macro_rules! config {
4
    ($($key:ident => $value:expr),* $(,)?) => {
5
        {
6
            let mut cfg = std::collections::HashMap::new();
7
            $(cfg.insert(stringify!($key).to_owned(), $value.to_string());)*
8
            cfg
9
        }
10
    };
11
}
12

13
// 模式 2：类型列表
14
// $(T: Trait),*
15
macro_rules! impl_display {
16
    ($($ty:ty),* $(,)?) => {
17
        $(impl std::fmt::Display for $ty {
18
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19
                write!(f, "{}", self)
20
            }
21
        })*
22
    };
23
}
24

25
// 注意：上述 impl_display 实际上会为已有 Display 的类型再次 impl，产生冲突。
26
// 实际中更常见的是为自定义类型批量 impl：
27

28
// 模式 3：嵌套重复——用不同变量名
29
macro_rules! matrix {
30
    ($([$($elem:expr),* $(,)?]),* $(,)?) => {
31
        vec![$(vec![$($elem),*]),*]
32
    };
33
}
34

35
let m = matrix! {
36
    [1, 2, 3],
37
    [4, 5, 6],
38
    [7, 8, 9],
39
};

1
macro_rules! confusing {
2
    ($val:expr) => {
3
        let mut sum = 0;
4
        // 这里的 $val 在宏调用者的 hygiene 域中
5
        // 如果 $val 引用了宏内变量，会编译失败
6
        sum += $val;
7
        sum
8
    };
9
}
10

11
fn test() {
12
    let result = confusing!(42);
13
    assert_eq!(result, 42);
14
    // 但如果写 confusing!(sum) 会编译失败
15
    // 因为 sum 在宏的 hygiene 域中，调用者看不到
16
}

1
// 声明宏版本：有限制——不支持泛型，不支持属性
2
macro_rules! builder {
3
    (
4
        $(#[$meta:meta])*
5
        $vis:vis struct $name:ident {
6
            $($field:ident : $ty:ty),* $(,)?
7
        }
8
    ) => {
9
        $(#[$meta])*
10
        $vis struct $name {
11
            $($field: $ty),*
12
        }
13

14
        impl $name {
15
            $(pub fn $field(mut self, val: $ty) -> Self {
16
                self.$field = val;
17
                self
18
            })*
19
        }
20
    };
21
}
22

23
// 问题：
24
// 1. 不能处理泛型 struct Foo<T> { ... }
25
// 2. 不能跳过某些字段（如 PhantomData）
26
// 3. 不能添加 Default bound
27
// 4. 错误信息无法定制
28

29
// → 升级到 derive 过程宏：#[derive(Builder)]