您现在的位置是:首页 >技术交流 >研读Rust圣经解析——Rust learn-16(高级trait,宏)网站首页技术交流

研读Rust圣经解析——Rust learn-16(高级trait,宏)

简明编程 2023-06-27 00:00:03
简介研读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 manipulate
    let ast = syn::parse(input).unwrap();

    // Build the trait implementation
    impl_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_fn

      for 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 结构体和枚举的通用 AST
    let 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! {
        #input

        fn #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);
}

风语者!平时喜欢研究各种技术,目前在从事后端开发工作,热爱生活、热爱工作。