RUST宏编程入门

宏指示符

在Rust的宏编程中，宏可以接受多种类型的参数，称为"指示符"。这些指示符帮助宏识别不同类型的代码片段，并相应地处理它们。

这里列出全部指示符：

• block
• expr 用于表达式
• ident 用于变量名或函数名
• item
• literal 用于字面常量
• pat (模式 pattern)
• path
• stmt (语句 statement)
• tt (标记树 token tree)
• ty (类型 type)
• vis (可见性描述符)

ident

ident：标识符，用于变量名、函数名、类型名等。

macro_rules! example {
    ($name:ident) => {
        let $name = 42;
    };
}
example!(x); // 展开为：let x = 42;

expr

expr：表达式，可以是任何合法的Rust表达式。

macro_rules! example {
    ($e:expr) => {
        println!("Result: {}", $e);
    };
}
example!(1 + 2); // 展开为：println!("Result: {}", 1 + 2);

ty

ty：类型，用于指定类型名称。

macro_rules! example {
    ($t:ty) => {
        let _x: $t;
    };
}
example!(i32); // 展开为：let _x: i32;

pat

pat：模式，用于模式匹配。

macro_rules! example {
    ($p:pat) => {
        match 42 {
            $p => println!("Matched!"),
            _ => println!("Not matched!"),
        }
    };
}
example!(x); // 展开为：match 42 { x => println!("Matched!"), _ => println!("Not matched!"), }

stmt

stmt：语句，用于单一语句。

macro_rules! example {
    ($s:stmt) => {
        $s
    };
}
example!(let x = 42;); // 展开为：let x = 42;

block

block：代码块，用于多个语句组成的代码块。

macro_rules! example {
    ($b:block) => {
        $b
    };
}
example!({
    let x = 42;
    println!("{}", x);
}); // 展开为：{ let x = 42; println!("{}", x); }

item

item：项，用于函数、结构体、模块等项。

macro_rules! example {
    ($i:item) => {
        $i
    };
}
example!(fn foo() {}); // 展开为：fn foo() {}

meta

meta：元数据项，用于属性。

macro_rules! example {
    ($m:meta) => {
        #[$m]
        fn foo() {}
    };
}
example!(test); // 展开为：#[test] fn foo() {}

tt

tt：令牌树，表示一个或多个令牌。

macro_rules! example {
    ($t:tt) => {
        $t
    };
}
example!(fn foo() {}); // 展开为：fn foo() {}

path

path ：路径，用于路径（例如模块路径）。
rust macro_rules! example { ($p:path) => { let _: $p; }; } example!(std::io::Error); // 展开为：let _: std::io::Error;

literal

literal ：字面量，用于常量值（字符串、数字等）。
rust macro_rules! example { ($l:literal) => { let x = $l; }; } example!("hello"); // 展开为：let x = "hello";

通过这些指示符，Rust的宏系统可以处理各种类型的输入，从而生成灵活且强大的代码。这些指示符使得宏在编写复杂代码时变得更加方便和可读。

代码示例

以下代码两个宏分别功能是创建函数和输出表达式及其结果

macro_rules! create_function {
    // 此宏接受一个 `ident` 指示符表示的参数，并创建一个名为 `$func_name` 的函数。
    // `ident` 指示符用于变量名或函数名
    ($func_name: ident) => (
        fn $func_name() {
            // `stringify!` 宏把 `ident` 转换成字符串。
            println!("You called {:?}()", stringify!($func_name))
        }
    )
}

// 借助上述宏来创建名为 `foo` 和 `bar` 的函数。
create_function!(foo);
create_function!(bar);

macro_rules! print_result {
    // 此宏接受一个 `expr` 类型的表达式，并将它作为字符串，连同其结果一起
    // 打印出来。
    // `expr` 指示符表示表达式。
    ($expression: expr) => (
        // `stringify!` 把表达式*原样*转换成一个字符串。
        println!("{:?} = {:?}", stringify!($expression), $expression)
    )
}

fn main() {
    foo();
    bar();

    print_result!(1u32 + 1);

    // 回想一下，代码块也是表达式！
    print_result!({
        let x = 1u32;
        x * x + 2 * x - 1
    });
}
``**