宏

https://danielkeep.github.io/tlborm/book/README.html

我们使用过像 println! 这样的宏了，不过还没完全探索什么是宏以及它是如何工作的。
宏（Macro）指的是 Rust 中一系列的功能：声明（Declarative）宏，使用 macro_rules!，和三种 过程（Procedural）宏：

• 自定义 #[derive] 宏在结构体和枚举上指定通过 derive 属性添加的代码
• 类属性（Attribute）宏定义可用于任意项的自定义属性
• 类函数宏看起来像函数不过作用于作为参数传递的 token。

宏和函数的区别

从根本上来说，宏是一种为写其他代码而写代码的方式，即所谓的 元编程（metaprogramming）。
我们使用过 println! 宏和 vec! 宏。
所有的这些宏以 展开 的方式来生成比你所手写出的更多的代码。

元编程对于减少大量编写和维护的代码是非常有用的，它也扮演了函数的角色。但宏有一些函数所没有的附加能力。

一个函数标签必须声明函数参数个数和类型。
相比之下，宏只接受一个可变参数：用一个参数调用 println!("hello") 或用两个参数调用 println!("hello {}", name)。
而且，宏可以在编译器翻译代码前展开，例如，宏可以在一个给定类型上实现 trait
因为函数是在运行时被调用，同时 trait 需要在运行时实现，所以函数无法像宏这样。

实现一个宏而不是函数的消极面是宏定义要比函数定义更复杂，因为你正在编写生成 Rust 代码的 Rust 代码。由于这样的间接性，宏定义通常要比函数定义更难阅读、理解以及维护。

宏和函数的最后一个重要的区别是：在调用宏 之前 必须定义并将其引入作用域，而函数则可以在任何地方定义和调用。

使用 macro_rules! 的声明宏用于通用元编程

Rust 最常用的宏形式是 声明宏（declarative macros）。
它们有时也被称为 “macros by example”、“macro_rules! 宏” 或者就是 “macros”。
其核心概念是，声明宏允许我们编写一些类似 Rust match 表达式的代码。
match 表达式是控制结构，其接收一个表达式，与表达式的结果进行模式匹配，然后根据模式匹配执行相关代码。
宏也将一个值和包含相关代码的模式进行比较；
此种情况下，该值是传递给宏的 Rust 源代码字面值，模式用于和传递给宏的源代码进行比较，同时每个模式的相关代码则用于替换传递给宏的代码。
所有这一切都发生于编译时。

可以使用 macro_rules! 来定义宏。

macro_rules! ten {
    () => { 10 };
}
fn main() {
    let x = 2 * ten!();
    println!("x = {}", x);
}
// x = 20

给宏传参数

macro_rules! ten_times {
    ($e: expr) => { 10 * $e };
}
fn main() {
    let x = ten_times!(2);
    println!("x = {}", x);
}
// x = 20

这里的$e是自己定的，写成$a,$b,$x,$foo之类的都可以，不过还是推荐写得语义化一些. expr是代表表达式expression的缩写

类型介绍：

expr: 表示式，expression
tt: 一个 token tree
ty: 一个类型，type
ident: 标识符
item: 结构体，函数，mod 之类的
block: 用大括号包起来的语句或者表达式，也就是代码块
stmt: 一段 statement
pat: 一段 pattern
path: 类似 foo::bar 这种路径
meta: 元类型，譬如 #[...], #![...] 内的东西

表达式比如有：1,a,x + y,add(1, 2)等
token tree 可以是: 1,a,(1 + 2),(a * 2333),(a + mul(6, 111))等，不可以写成1 + 2这种形式，只能是token tree中的一个结点

macro_rules! test {
    ( $x: tt + $y: tt ) => {
        {
            println!("x = {}, y = {}", $x, $y);
        }
    }
}
fn main() {
    test!(1 + 2);
}
x = 1, y = 2

macro_rules! test {
    ( $x:expr ) => {
        {
            println!("x = {}", $x);
        }
    }
}
fn main() {
    test!(1 + 2);
}
x = 3

macro_rules! test {
    ( $x:tt ) => {
        {
            println!("x = {}", $x);
        }
    }
}
fn main() {
    test!(1 + 2);
}
error: no rules expected the token `+`
 --> src/main.rs:9:13
  |
1 | macro_rules! test {
  | ----------------- when calling this macro
...
9 |     test!(1 + 2);
  |             ^ no rules expected this token in macro call

macro_rules! test {
    ( $x:tt ) => {
        {
            println!("x = {}", $x);
        }
    }
}
fn main() {
    test!((1 + 2));
}
// x = 3

macro_rules! test {
    ( $x:tt ) => {
        {
            println!("x = {}", $x);
        }
    }
}
fn add(a: i32, b: i32) -> i32 {
    a + b
}
fn main() {
    // test!(add(1, 2));  // 错误写法
    test!((add(1, 2)));  // 正确写法
}

macro_rules! test {
    ( $e: expr, $pattern: pat ) => {
        match $e {
            $pattern => {
                true
            },
            _ => false
        }
    }
}
fn main() {
    let a = Some(true);
    let x = test!(a, Some(true));
    println!("{}", x);
}
// true

重复

*表示重复使用，$()包裹的内容来处理传进来的值

让我们来看看 vec! 宏定义。

例如，下面的宏用三个整数创建一个 vector：

let v: Vec<u32> = vec![1, 2, 3];

也可以使用 vec! 宏来构造两个整数的 vector 或五个字符串 slice 的 vector 。
但却无法使用函数做相同的事情，因为我们无法预先知道参数值的数量和类型。

一个 vec! 宏定义的简化版本:

文件名: src/lib.rs

#[macro_export]
macro_rules! vec {
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

注意：标准库中实际定义的 vec! 包括预分配适当量的内存的代码。这部分为代码优化，为了让示例简化，此处并没有包含在内。

无论何时导入定义了宏的包，#[macro_export] 注解说明宏应该是可用的。 如果没有该注解，这个宏不能被引入作用域。

接着使用 macro_rules! 和宏名称开始宏定义，且所定义的宏并 不带 感叹号。名字后跟大括号表示宏定义体，在该例中宏名称是 vec 。

vec! 宏的结构和 match 表达式的结构类似。此处有一个单边模式 ( $( $x:expr ),* ) ，后跟 => 以及和模式相关的代码块。
如果模式匹配，该相关代码块将被执行。
假设这是这个宏中唯一的模式，则只有这一种有效匹配，其他任何匹配都是错误的。更复杂的宏会有多个单边模式。

首先，一对括号包含了全部模式。接下来是后跟一对括号的美元符号 ( $ )，其通过替代代码捕获了符合括号内模式的值。$() 内则是 $x:expr ，其匹配 Rust 的任意表达式或给定 $x 名字的表达式。

$() 之后的逗号说明一个逗号分隔符可以有选择的出现代码之后，这段代码与在 $() 中所捕获的代码相匹配。紧随逗号之后的* 说明该模式匹配零个或多个 * 之前的任何模式。

当以 vec![1, 2, 3]; 调用宏时，$x 模式与三个表达式 1、2 和 3 进行了三次匹配。

现在让我们来看看这个出现在与此单边模式相关的代码块中的模式：在 $()* 部分中所生成的 temp_vec.push() 为在匹配到模式中的 $() 每一部分而生成。
$x 由每个与之相匹配的表达式所替换。
当以 vec![1, 2, 3]; 调用该宏时，替换该宏调用所生成的代码会是下面这样：

let mut temp_vec = Vec::new();
temp_vec.push(1);
temp_vec.push(2);
temp_vec.push(3);
temp_vec

我们已经定义了一个宏，其可以接收任意数量和类型的参数，同时可以生成能够创建包含指定元素的 vector 的代码。

递归

macro_rules! add {
    ( $x:expr ) => {
        $x
    };
    ( $x:expr, $($y:expr),* ) => {
        $x + add!($($y),*)
    };
}
fn main() {
    let res = add!(1, 2, 3, 4, 5, 6);
    println!("res = {}", res);
}
// res = 21

macro_rules! min {
    ( $x:expr ) => {
        $x
    };
    ( $x:expr, $($y:expr),* ) => {
        $x.min(min!($($y),*))
    };
}
fn main() {
    let res = min!(1, 2, 3, 4, 5, 6);
    println!("res = {}", res);
}
// res = 1

macro_rules! 中有一些奇怪的地方。
在将来，会有第二种采用 macro 关键字的声明宏，其工作方式类似但修复了这些极端情况。
在此之后，macro_rules! 实际上就过时（deprecated）了。

用于从属性生成代码的过程宏

第二种形式的宏被称为 过程宏（procedural macros），因为它们更像函数（一种过程类型）。
过程宏接收 Rust 代码作为输入，在这些代码上进行操作，然后产生另一些代码作为输出，而非像声明式宏那样匹配对应模式然后以另一部分代码替换当前代码。

有三种类型的过程宏（自定义 derive，类属性和类函数），不过它们的工作方式都类似。

当创建过程宏时，其定义必须位于一种特殊类型的属于它们自己的 crate 中。这么做出于复杂的技术原因，将来我们希望能够消除这些限制。

使用这些宏需采用类似示例所示的代码形式，其中 some_attribute 是一个使用特定宏的占位符。

文件名: src/lib.rs

一个使用过程宏的例子:

use proc_macro;

#[some_attribute]
pub fn some_name(input: TokenStream) -> TokenStream {

}

过程宏包含一个函数，这也是其得名的原因：“过程” 是 “函数” 的同义词。
那么为何不叫 “函数宏” 呢？好吧，有一个过程宏是 “类函数” 的，叫成函数会产生混乱。
无论如何，定义过程宏的函数接受一个 TokenStream 作为输入并产生一个 TokenStream 作为输出。
这也就是宏的核心：宏所处理的源代码组成了输入 TokenStream，同时宏生成的代码是输出 TokenStream。
最后，函数上有一个属性；这个属性表明过程宏的类型。在同一 crate 中可以有多种的过程宏。

考虑到这些宏是如此类似，我们会从自定义派生宏开始。接着会解释与其他形式宏的微小区别。

如何编写自定义 derive 宏

让我们创建一个 hello_macro crate，其包含名为 HelloMacro 的 trait 和关联函数 hello_macro。
不同于让 crate 的用户为其每一个类型实现 HelloMacro trait，我们将会提供一个过程式宏以便用户可以使用 #[derive(HelloMacro)] 注解他们的类型来得到 hello_macro 函数的默认实现。
该默认实现会打印 Hello, Macro! My name is TypeName!，其中 TypeName 为定义了 trait 的类型名。
换言之，我们会创建一个 crate，使程序员能够写类似示例中的代码。

文件名: src/main.rs

crate 用户所写的能够使用过程式宏的代码:

use hello_macro::HelloMacro;
use hello_macro_derive::HelloMacro;

#[derive(HelloMacro)]
struct Pancakes;

fn main() {
    Pancakes::hello_macro();
}

运行该代码将会打印 Hello, Macro! My name is Pancakes! 第一步是像下面这样新建一个库 crate：

➜  Desktop cargo new hello_macro --lib
     Created library `hello_macro` package

接下来，会定义 HelloMacro trait 以及其关联函数：

文件名: src/lib.rs

pub trait HelloMacro {
    fn hello_macro();
}

现在有了一个包含函数的 trait 。此时，crate 用户可以实现该 trait 以达到其期望的功能，像这样：

use hello_macro::HelloMacro;

struct Pancakes;

impl HelloMacro for Pancakes {
    fn hello_macro() {
        println!("Hello, Macro! My name is Pancakes!");
    }
}

fn main() {
    Pancakes::hello_macro();
}

然而，他们需要为每一个他们想使用 hello_macro 的类型编写实现的代码块。我们希望为其节约这些工作。

另外，我们也无法为 hello_macro 函数提供一个能够打印实现了该 trait 的类型的名字的默认实现：Rust 没有反射的能力，因此其无法在运行时获取类型名。
我们需要一个在运行时生成代码的宏。

下一步是定义过程式宏。
在编写本部分时，过程式宏必须在其自己的 crate 内。该限制最终可能被取消。
构造 crate 和其中宏的惯例如下：对于一个 foo 的包来说，一个自定义的派生过程宏的包被称为 foo_derive 。
在 hello_macro 项目中新建名为 hello_macro_derive 的包。

➜  hello_macro git:(master) ✗ cargo new hello_macro_derive --lib
     Created library `hello_macro_derive` package

由于两个 crate 紧密相关，因此在 hello_macro 包的目录下创建过程式宏的 crate。
如果改变在 hello_macro 中定义的 trait ，同时也必须改变在 hello_macro_derive 中实现的过程式宏。
这两个包需要分别发布，编程人员如果使用这些包，则需要同时添加这两个依赖并将其引入作用域。
我们也可以只用 hello_macro 包而将 hello_macro_derive 作为一个依赖，并重新导出过程式宏的代码。
但我们组织项目的方式使编程人员使用 hello_macro 成为可能，即使他们无需 derive 的功能。

需要将 hello_macro_derive 声明为一个过程宏的 crate。
同时也需要 syn 和 quote crate 中的功能，正如注释中所说，需要将其加到依赖中。
为 hello_macro_derive 将下面的代码加入到 Cargo.toml 文件中。

文件名: hello_macro_derive/Cargo.toml

[lib]
proc-macro = true

[dependencies]
syn = "0.14.4"
quote = "0.6.3"

为定义一个过程式宏，请将示例中的代码放在 hello_macro_derive crate 的 src/lib.rs 文件里面。
注意这段代码在我们添加 impl_hello_macro 函数的定义之前是无法编译的。

大多数过程式宏处理 Rust 代码时所需的代码:

extern crate proc_macro;

use crate::proc_macro::TokenStream;
use quote::quote;
use syn;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    // 构建 Rust 代码所代表的语法树
    // 以便可以进行操作
    let ast = syn::parse(input).unwrap();

    // 构建 trait 实现
    impl_hello_macro(&ast)
}

注意 hello_macro_derive 函数中代码分割的方式，它负责解析 TokenStream，而 impl_hello_macro 函数则负责转换语法树：这让编写一个过程式宏更加方便。
外部函数中的代码（在这里是 hello_macro_derive）几乎在所有你能看到或创建的过程宏 crate 中都一样。
内部函数（在这里是 impl_hello_macro）的函数体中所指定的代码则依过程宏的目的而各有不同。

现在，我们已经引入了三个新的 crate：proc_macro 、 syn 和 quote 。
Rust 自带 proc_macro crate，因此无需将其加到 Cargo.toml 文件的依赖中。
proc_macro crate 是编译器用来读取和操作我们 Rust 代码的 API。

syn crate 将字符串中的 Rust 代码解析成为一个可以操作的数据结构。
quote 则将 syn 解析的数据结构反过来传入到 Rust 代码中。
这些 crate 让解析任何我们所要处理的 Rust 代码变得更简单：为 Rust 编写整个的解析器并不是一件简单的工作。

当用户在一个类型上指定 #[derive(HelloMacro)] 时，hello_macro_derive 函数将会被调用。
原因在于我们已经使用 proc_macro_derive 及其指定名称对 hello_macro_derive 函数进行了注解：HelloMacro ，其匹配到 trait 名，这是大多数过程宏遵循的习惯。

该函数首先将来自 TokenStream 的 input 转换为一个我们可以解释和操作的数据结构。
这正是 syn 派上用场的地方。
syn 中的 parse_derive_input 函数获取一个 TokenStream 并返回一个表示解析出 Rust 代码的 DeriveInput 结构体。
示例展示了从字符串 struct Pancakes; 中解析出来的 DeriveInput 结构体的相关部分：

解析示例中带有宏属性的代码时得到的 DeriveInput 实例:

DeriveInput {
    // --snip--

    ident: Ident {
        ident: "Pancakes",
        span: #0 bytes(95..103)
    },
    data: Struct(
        DataStruct {
            struct_token: Struct,
            fields: Unit,
            semi_token: Some(
                Semi
            )
        }
    )
}

该结构体的字段展示了我们解析的 Rust 代码是一个类单元结构体，其 ident（ identifier，表示名字）为 Pancakes。

此时，尚未定义 impl_hello_macro 函数，其用于构建所要包含在内的 Rust 新代码。
但在此之前，注意其输出也是 TokenStream。所返回的 TokenStream 会被加到我们的 crate 用户所写的代码中，因此，当用户编译他们的 crate 时，他们会获取到我们所提供的额外功能。

你可能也注意到了，当调用 parse_derive_input 或 parse 失败时。
在错误时 panic 对过程宏来说是必须的，因为 proc_macro_derive 函数必须返回 TokenStream 而不是 Result，以此来符合过程宏的 API。
这里选择用 unwrap 来简化了这个例子；在生产代码中，则应该通过 panic! 或 expect 来提供关于发生何种错误的更加明确的错误信息。

现在我们有了将注解的 Rust 代码从 TokenStream 转换为 DeriveInput 实例的代码，让我们来创建在注解类型上实现 HelloMacro trait 的代码，如示例所示。

文件名: hello_macro_derive/src/lib.rs

使用解析过的 Rust 代码实现 HelloMacro trait:

fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
    let name = &ast.ident;
    let gen = quote! {
        impl HelloMacro for #name {
            fn hello_macro() {
                println!("Hello, Macro! My name is {}", stringify!(#name));
            }
        }
    };
    gen.into()
}

我们得到一个包含以 ast.ident 作为注解类型名字（标识符）的 Ident 结构体实例。

quote! 让我们可以编写希望返回的 Rust diamagnetic。
quote! 宏执行的直接结果并不是编译器所期望的并需要转换为 TokenStream。
为此需要调用 into 方法，它会消费这个中间表示（intermediate representation，IR）并返回所需的 TokenStream 类型值。

这个宏也提供了一些非常酷的模板机制；我们可以写 #name ，然后 quote! 会以 名为 name 的变量值来替换它。
你甚至可以做些与这个正则宏任务类似的重复事情。

我们期望我们的过程式宏能够为通过 #name 获取到的用户注解类型生成 HelloMacro trait 的实现。
该 trait 的实现有一个函数 hello_macro ，其函数体包括了我们期望提供的功能：打印 Hello, Macro! My name is 和注解的类型名。

此处所使用的 stringify! 为 Rust 内置宏。
其接收一个 Rust 表达式，如 1 + 2 ，然后在编译时将表达式转换为一个字符串常量，如 "1 + 2" 。
这与 format! 或 println! 是不同的，它计算表达式并将结果转换为 String 。
有一种可能的情况是，所输入的 #name 可能是一个需要打印的表达式，因此我们用 stringify!
stringify! 编译时也保留了一份将 #name 转换为字符串之后的内存分配。

此时，cargo build 应该都能成功编译 hello_macro 和 hello_macro_derive 。
在 projects 目录下用 cargo new pancakes 命令新建一个二进制项目。
需要将 hello_macro 和 hello_macro_derive 作为依赖加到 pancakes 包的 Cargo.toml 文件中去。
如果你正将 hello_macro 和 hello_macro_derive 的版本发布到 crates.io 上，其应为正规依赖；如果不是，则可以像下面这样将其指定为 path 依赖：

[dependencies]
hello_macro = { path = "../hello_macro" }
hello_macro_derive = { path = "../hello_macro/hello_macro_derive" }

执行 cargo run：其应该打印 Hello, Macro! My name is Pancakes!。
其包含了该过程宏中 HelloMacro trait 的实现，而无需 pancakes crate 实现它；#[derive(HelloMacro)] 增加了该 trait 实现。

接下来，让我们探索一下其他类型的过程宏与自定义派生宏有何区别。

类属性宏

类属性宏与自定义派生宏相似，不同于为 derive 属性生成代码，它们允许你创建新的属性。
它们也更为灵活；derive 只能用于结构体和枚举；属性还可以用于其它的项，比如函数。
作为一个使用类属性宏的例子，可以创建一个名为 route 的属性用于注解 web 应用程序框架（web application framework）的函数：

#[route(GET, "/")]
fn index() {

#[route] 属性将由框架本身定义为一个过程宏。其宏定义的函数签名看起来像这样：

#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {

这里有两个 TokenStream 类型的参数；第一个用于属性内容本身，也就是 GET, "/" 部分。
第二个是属性所标记的项，在本例中，是 fn index() {} 和剩下的函数体。

除此之外，类属性宏与自定义派生宏工作方式一致：创建 proc-macro crate 类型的 crate 并实现希望生成代码的函数！

类函数宏

类函数宏定义看起来像函数调用的宏。
类似于 macro_rules!，它们比函数更灵活；例如，可以接受未知数量的参数。
然而 macro_rules! 宏只能使用之前 “使用 macro_rules! 的声明宏用于通用元编程” 介绍的类匹配的语法定义。
类函数宏获取 TokenStream 参数，其定义使用 Rust 代码操纵 TokenStream，就像另两种过程宏一样。一个类函数宏例子是可以像这样被调用的 sql! 宏：

let sql = sql!(SELECT * FROM posts WHERE id=1);
这个宏会解析其中的 SQL 语句并检查其是否是句法正确的，这是比 macro_rules! 可以做到的更为复杂的处理。sql! 宏应该被定义为如此：

#[proc_macro]
pub fn sql(input: TokenStream) -> TokenStream {

这类似于自定义派生宏的签名：获取括号中的 token，并返回希望生成的代码。