研读Rust圣经解析——Rust learn-16（高级trait，宏）

高级trait

关联类型Type

我们使用type关键字即可声明一个关联类型，关联类型的作用就是简化和隐藏显示类型（个人认为）

• 简化：一个很长的类型总是被需要时，需要开发者耗费精力的重复书写，而且若有改动，则需要改多个地方
• 隐藏：对外部调用者隐藏，外部调用者无需知道它指的是什么，只要可快速使用即可

trait test {type Res = Result<i32, Box<&'static str>>;fn test_res() -> Res{//...}
}

为什么不用泛型而是Type

使用泛型，我们就需要在每次使用实现时显示的标注类型，但是当针对一个多处使用且无需修改类型的场景时，无疑耗时耗力，换而言之，Type牺牲部分灵活度换取常用性

运算符重载（重要等级不高）

Rust 并不允许创建自定义运算符或重载任意运算符，不过 std::ops 中所列出的运算符和相应的 trait 可以通过实现运算符相关 trait 来重载
因此我们就可以重载例如+，/，-，*等，
以下是官方给出的例子：

use std::ops::Add;#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {x: i32,y: i32,
}impl Add for Point {type Output = Point;fn add(self, other: Point) -> Point {Point {x: self.x + other.x,y: self.y + other.y,}}
}fn main() {assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },Point { x: 3, y: 3 });
}

重名方法消除歧义

当我们实现多个trait的时候，若遇到多个trait有同样的方法名，那么就会产生重名歧义，此时最晚实现的会覆盖前面的，为了消除歧义，我们可以采用trait::fn(&type)来申明调用

struct a {}trait b {fn get(&self) {}
}trait c {fn get(&self) {}
}impl b for a {fn get(&self) {todo!()}
}impl c for a {fn get(&self) {todo!()}
}fn main() {let a_struct = a {};b::get(&a_struct);c::get(&a_struct);
}

never type

Rust 有一个叫做 ! 的特殊类型，我们称作never type因为他表示函数从不返回的时候充当返回值

fn no_feedback()->!{//...
}

continue 的值是 !

        let guess: u32 = match guess.trim().parse() {Ok(num) => num,Err(_) => continue,};

返回闭包

一个函数的返回值是可以为一个闭包的，这个没有限制，具体来说我们简单了解写法即可

fn test()->Box<dyn Fn()>{//...
}

我们通过返回一个Box即将返回值写入堆中
例如：

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {Box::new(|x| x + 1)
}

宏

从根本上来说，宏是一种为写其他代码而写代码的方式，即所谓的 元编程（metaprogramming）。在附录 C 中会探讨 derive 属性，其生成各种 trait 的实现。我们也在本书中使用过 println! 宏和 vec! 宏。所有的这些宏以 展开 的方式来生成比你所手写出的更多的代码。

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

一个函数签名必须声明函数参数个数和类型。相比之下，宏能够接收不同数量的参数：用一个参数调用 println!(“hello”) 或用两个参数调用 println!(“hello {}”, name) 。而且，宏可以在编译器翻译代码前展开，例如，宏可以在一个给定类型上实现 trait。而函数则不行，因为函数是在运行时被调用，同时 trait 需要在编译时实现。

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

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

—https://kaisery.github.io/trpl-zh-cn/ch19-06-macros.html

自定义宏（声明宏）

接下来我们就直接自定义宏，少说废话，直接开干（为什么要学这个？因为甚至可以使用这个自己写一门语言）

宏的运作机制

Rust编译过程

新建空白宏

创建空白宏的方式很简单，直接使用macro_rules!进行声明，内部形似模式匹配推断（其实根本就是）

macro_rules! test {() => {};
}

宏选择器

1. item：条目，例如函数、结构、模块等
2. block：代码块
3. stmt：语句
4. pat：模式
5. expr：表达式
6. ty：类型
7. ident：标识符
8. path：路径，例如 foo、 ::std::mem::replace, transmute::<_, int>, …
9. meta：元信息条目，例如 #[…]和 #![rust macro…] 属性
10. tt：词条树

什么是词条树

tt词条树是指Rust编译器使用的一种数据结构，通常用于处理宏(Macro)和代码生成(Code Generation)。

tt指的是"Token Tree"，它是由一系列"Token"构成的树形结构。"Token"是编程语言中最基础的语法单元，例如关键字、标识符、运算符、括号等等。而"Token Tree"则是这些"Token"按一定的层次结构排列而成的树。

在Rust语言中，宏通常是使用tt词条树作为输入，它可以让宏定义更加灵活和强大。通过对tt词条树进行递归、遍历和变换，宏可以生成代码，实现元编程(Metaprogramming)的效果。

除了宏之外，Rust编译器还会使用tt词条树来处理一些代码生成工作，例如构建抽象语法树(AST)或者生成代码的中间表示(IR)等等。

宏选择器设置各类入参

我们通过挑选适合的宏选择器，才能对应我们宏接受的参数

实现一个log宏

use std::time::{Instant, SystemTime, UNIX_EPOCH};
macro_rules! log {($log_name:tt)=>{let now = SystemTime::now();let timestamp = now.duration_since(UNIX_EPOCH).unwrap().as_secs();println!("=======================start-{}=========================",$log_name);println!("----------------createTime:{:?}",timestamp);println!("----------------title:{}",$log_name);println!("========================end-{}========================",$log_name);};
}fn main() {log!("zhangsan");
}

运行重复模式匹配

当我们有多个入参的时候就需要用到这个了，比如println！这个宏，我们可能会传入多个需要打印的内容，如果各个要取个名字，那么这样为什么还要去编写一个统一的，简化的宏呢？
重复模式匹配语法：

($($x:expr),*)=>{}

use std::time::{Instant, SystemTime, UNIX_EPOCH};
macro_rules! eq_judge {($($left:expr => $right:expr),*)=>{{$(if $left == $right{println!("true")})*}}
}fn main() {eq_judge!("hello"=>"hi","no"=>"no");
}

自定义derive宏(过程宏)

与上面的不一样的是，这个derive宏标注的位置在一般在结构体、enum上
比如:

#[derive(Debug)]
struct a{}

构建项目结构（一定要照着做不然会错）

以下是官方案例，我做了一遍之后重写顺序并强调犯错点，请大家一定要按照顺序做，遇到错误查看我这里写的错误

设置工作空间

首先随便创建一个项目，然后修改toml文件

• hello_macro：声明需要实现的trait
• hello_macro_derive：具体的解析，转化，处理逻辑
• pancakes：主执行包

[workspace]
members=["hello_macro","hello_macro_derive","pancakes"
]

创建lib和main

cargo new hello_macro --lib
cargo new hello_macro_derive --lib
cargo new pancakes

结构如下图：

hello_macro

lib.rs

书写需要实现的trait并使用pub暴露

pub trait HelloMacro {fn hello_macro();
}

hello_macro_derive

添加依赖和激活proc-macro

syn crate 将字符串中的 Rust 代码解析成为一个可以操作的数据结构。quote 则将 syn 解析的数据结构转换回 Rust 代码。这些 crate 让解析任何我们所要处理的 Rust 代码变得更简单：为 Rust 编写整个的解析器并不是一件简单的工作。
proc-macro表示这个cratq是一个proc-macro，增加这个配置以后，这个crate的特性就会发生一些变化，例如，这个crate将只能对外导出内部定义的过程宏，而不能导出内部定义的其他内容。

cargo add syn
cargo add quote

[package]
name = "hello_macro_derive"
version = "0.1.0"
edition = "2021"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[lib]
proc-macro=true[dependencies]
quote = "1.0.26"
syn = "2.0.15"

lib.rs

#[proc_macro_derive(HelloMacro)]标识只要是结构体、enum上标注#[derive(HelloMacro)]后就会自动实现HelloMacro这个trait，具体的实现逻辑实际上在impl_hello_macro函数中

use proc_macro::TokenStream;
use quote::quote;
use syn;#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {// Construct a representation of Rust code as a syntax tree// that we can manipulatelet ast = syn::parse(input).unwrap();// Build the trait implementationimpl_hello_macro(&ast)
}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()
}

注意点（请好好读，官网上说的很清楚了，这个地方一定要搞懂）

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

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

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

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

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

pancakes

添加依赖

这里我们需要依赖我们自己写的lib所以需要用path指明

[package]
name = "pancakes"
version = "0.1.0"
edition = "2021"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[dependencies]
hello_macro = { path = "../hello_macro" }
hello_macro_derive = { path = "../hello_macro_derive" }

main.rs

use hello_macro::HelloMacro;
use hello_macro_derive::HelloMacro;#[derive(HelloMacro)]
struct Pancakes;fn main() {Pancakes::hello_macro();
}

错误

can’t find library marco_t, rename file to src/lib.rs or specify lib.path （为什么不能在单项目包里构建）

若你仅仅在一个包中构建，当你添加[lib] proc-macro = true你会出现以下错误:

Caused by:can't find library `marco_t`, rename file to `src/lib.rs` or specify lib.path

这说明我们不能把当前的包作为lib，因为是主执行包
原理︰考虑过程宏是在编译一个crate之前，对crate的代码进行加工的一段程序，这段程序也是需要编译后执行的。如果定义过程宏和使用过程宏的代码写在一个crate中，那就陷入了死锁:
要编译的代码首先需要运行过程宏来展开，否则代码是不完整的，没法编译crate.
不能编译crate，crate中的过程宏代码就没法执行，就不能展开被过程宏装饰的代码

can’t use a procedural macro from the same crate that defines it

那假如直接去掉不管这个，你会看到这个错误，意味着你必须将过程宏构建在lib中

自定义类属性宏（个人认为最重要）

类属性宏与自定义派生宏相似，不同的是 derive 属性生成代码，它们（类属性宏）能让你创建新的属性。它们也更为灵活；derive 只能用于结构体和枚举；属性还可以用于其它的项，比如函数

常见于各类框架中！

一个简单的例子

项目包结构

同自定义过程宏
我们需要把正在的解析处理逻辑放在lib下

[workspace]
members=[
"json_marco","json_test"
]

json_marco

添加依赖

[package]
name = "json_marco"
version = "0.1.0"
edition = "2021"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[lib]
proc-macro = true[dependencies]
proc-macro2 = "1.0.56"
quote = "1.0.26"
syn = { version = "2.0.15", features = ["full"] }

编写lib

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};#[proc_macro_attribute]
pub fn my_macro(attr:TokenStream,item:TokenStream)->TokenStream{println!("test");println!("{:#?}",attr);println!("{:#?}",item);item
}

这很简单就是单纯输出一下

json_test

toml映引入

[package]
name = "json_test"
version = "0.1.0"
edition = "2021"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[dependencies]
json_marco={path= "../json_marco"}

main.rs

use json_marco::my_macro;#[my_macro("test111")]
fn test(a: i32) {println!("{}", a);
}fn main() {test(5);
}

一些例子

base

lib

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};#[proc_macro_attribute]
pub fn my_macro(attr: TokenStream, item: TokenStream) -> TokenStream {// 解析输入的类型let input = parse_macro_input!(item as DeriveInput);// 获取类型名let name = input.ident;// 构建实现代码let expanded = quote! {impl #name {fn my_function(&self) {println!("This is my custom function!");}}};// 将生成的代码转换回 TokenStream 以供返回TokenStream::from(expanded)
}

main

#[my_macro]
struct MyStruct {field1: u32,field2: String,
}fn main() {let my_instance = MyStruct { field1: 42, field2: "hello".to_string() };my_instance.my_function();
}

flaky_test

lib

extern crate proc_macro;
extern crate syn;
use proc_macro::TokenStream;
use quote::quote;#[proc_macro_attribute]
pub fn flaky_test(_attr: TokenStream, input: TokenStream) -> TokenStream {let input_fn = syn::parse_macro_input!(input as syn::ItemFn);let name = input_fn.sig.ident.clone();TokenStream::from(quote! {#[test]fn #name() {#input_fnfor i in 0..3 {println!("flaky_test retry {}", i);let r = std::panic::catch_unwind(|| {#name();});if r.is_ok() {return;}if i == 2 {std::panic::resume_unwind(r.unwrap_err());}}}})
}

main

#[flaky_test::flaky_test]
fn my_test() {assert_eq!(1, 2);
}

json_parse

lib.rs

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields};#[proc_macro_attribute]
pub fn serde_json(_args: TokenStream, input: TokenStream) -> TokenStream {// 将输入解析为 DeriveInput 类型，这是所有 Rust 结构体和枚举的通用 ASTlet input = parse_macro_input!(input as DeriveInput);// 检查这是否是一个结构体，并拿到它的名称、字段列表等信息let struct_name = input.ident;let fields = match input.data {Data::Struct(data_struct) => data_struct.fields,_ => panic!("'serde_json' can only be used with structs!"),};// 生成代码，将结构体转换为 JSON 字符串let output = match fields {Fields::Named(fields_named) => {let field_names = fields_named.named.iter().map(|f| &f.ident);quote! {impl #struct_name {pub fn to_json(&self) -> String {serde_json::to_string(&json!({#(stringify!(#field_names): self.#field_names,)*})).unwrap()}}}}Fields::Unnamed(fields_unnamed) => {let field_indices = 0..fields_unnamed.unnamed.len();quote! {impl #struct_name {pub fn to_json(&self) -> String {serde_json::to_string(&json!([#(self.#field_indices,)*])).unwrap()}}}}Fields::Unit => {quote! {impl #struct_name {pub fn to_json(&self) -> String {serde_json::to_string(&json!({})).unwrap()}}}}};// 将生成的代码作为 TokenStream 返回output.into()
}

main.rs

#[serde_json]
struct MyStruct {name: String,age: u32,
}fn main() {let my_struct = MyStruct {name: "Alice".to_string(),age: 25,};let json_str = my_struct.to_json();println!("JSON string: {}", json_str);
}

fn_time

lib

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};#[proc_macro_attribute]
pub fn run(_args: TokenStream, input: TokenStream) -> TokenStream {// 将输入解析为函数节点let input = parse_macro_input!(input as ItemFn);// 获取函数名称、参数列表等信息let func_name = &input.ident;let func_args = &input.decl.inputs;// 生成代码，在函数开始和结束时分别打印时间戳let output = quote! {#inputfn #func_name(#func_args) -> () {println!("{} started", stringify!(#func_name));let start = std::time::Instant::now();let result = #func_name(#func_args);let end = start.elapsed();println!("{} finished in {}ms", stringify!(#func_name), end.as_millis());result}};// 将生成的代码作为 TokenStream 返回output.into()
}

main

#[run]
fn my_function() -> i32 {// 模拟一些处理时间std::thread::sleep(std::time::Duration::from_secs(1));42
}fn main() {let result = my_function();println!("Result = {}", result);
}