Rust中derive宏的作用及常用trait

在Rust代码经常可以看到在struct的上面，有一行#[derive(Clone, Debug)]这样的代码。dervice是Rust的内置宏，可以自动为struct或是enum实现某些的trait。
在下面的代码中，Book struct 通过derive宏自动实现了Debug、Clone和PartialEq这三个trait。

/// Defines a Column for an Entity
#[derive(Debug, Clone, PartialEq)]
pub struct Book {
    pub title: String,
    pub isbn : String,
    pub price: i32,
    pub author: String,
}
1
2
3
4
5
6
7
8

所谓自动实现，就是不用您自己写实现代码。

本文会介绍在Rust中常见的几个trait。

Debug trait

Debug trait为例，它应该是rust中最常用的trait了，包含一个方法fmt，是使用指定的Formatter来格式struct或enum中的值。

fn fmt(&self, f: &mut Formatter<'_>) -> Result;
1

当使用derive自动Debug实现时，Rust的编译器会自动生成实现Debugtrait的代码，可以减少代码编写的工作量。

我们经常要在代码加入一些debug的日志，比如要打印Book实例的具体内容。

println!("{:#?}",book);
1

在这里println宏会调用Book的fmt方法，得到格式化后的结果，然后输出给stdout。如果Book没有实现Debugtrait，这里就会编译错误。

Clone trait

看名字大家也就可以猜到，这个trait是用来复制实例的。在Rust中什么情况下需要clone一个实例呢？为什么默认为实例实现这个trait呢？

1. 显式控制 ：Rust强调显式性和安全性。所以默认并没有为所有的类型实现这个trati，它确保开发人员知道并明确允许克隆行为。这有助于防止由于不加选择地克隆而导致的意外性能问题或意外行为。

2. 避免借用：在Rust中，通过引用（borrowing）传递值是避免不必要复制并维护所有权语义的默认方式，然而，在需要创建具有自己所有权的新实例的情况下，Clone提供了一种无需借用的方法。这种情况在新手刚使用Rust的时候经常会碰到，常会碰到编译器提示，所有权已经在某处move了，提示需要clone这个实例。

#[derive(Clone)]
struct Person {
    name: String,
    age: u32,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 25,
    };
	
    let cloned_person = person.clone(); //这一行如果不调用clone，则会发生所有权的转移。那么下一行的代码就会无法编译。

    // 原始对象仍然有效
    println!("Original: {}, {}", person.name, person.age);

    // 克隆对象可用
    println!("Clone: {}, {}", cloned_person.name, cloned_person.age);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 深拷贝：如果定义的结构体中不仅包含基本类型，还包含其它结构体，则在Clone的时候 ，通常希望创建深拷贝，这意味着不仅复制顶层结构，还要复制所有嵌套数据。Clone trait提供了一种类型定义如何克隆的方法，允许它们实现自定义的深度复制行为。

4. 定制克隆：有时候我们Clone的时候，并不希望Clone原实例的所有的值，可能只希望部分数值被Clone到新实例（具体场景当用到的时候自然就会知道）。

上面的4种场景，除了场景4其它都可以直接用devive宏来实现，第4种场景就需要手动实现Clone trait，实现Clone的逻辑。

PartialEq trait

在Rust里 PartialEq和Eq这两个trait也挺让人迷惑的。

PartialEq，故名思义，是部分相等。这个trait有两个方法：

pub trait PartialEq<Rhs = Self>where
    Rhs: ?Sized,{
    // Required method
    fn eq(&self, other: &Rhs) -> bool;

    // Provided method
    fn ne(&self, other: &Rhs) -> bool { ... }
}
1
2
3
4
5
6
7
8

只需要实现eq这个方法即可。那么Partial体现在哪儿呢？比如有个Book结构体，包含isbn和format两个字段，只要isbn相等，就可以认为两个Book是相等的，从这个意义上看，只有部分字段相等就可以认为相等，所以称Partial。

enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq for Book {
    fn eq(&self, other: &Self) -> bool {
        self.isbn == other.isbn
    }
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };
let b2 = Book { isbn: 3, format: BookFormat::Ebook };
let b3 = Book { isbn: 10, format: BookFormat::Paperback };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

另外，跟Eq trait相比，PartialEq不满足自反性。
所谓自反性，就是一个类型的所有实例应该跟它自己相等，如果不是这个类型就不满足Eq,它就是PartialEq。这样说比较抽象，举个例子来说明。

fn main() {
    let f1 = 3.14;
    is_eq(f1);
    is_partial_eq(f1)
}

fn is_eq<T: Eq>(f: T) {}
fn is_partial_eq<T: PartialEq>(f: T) {}
1
2
3
4
5
6
7
8

运行上面的代码，会发现float并没有实现Eq，这很奇怪吧？

 is_eq(f1);
       ----- ^^ the trait `Eq` is not implemented for `{float}`
1
2

这是因为浮点数有一个特殊的值 NaN，它是无法进行相等性比较的，也就是NaN == NaN是不成立的。如果你的struct也有类似的情况，那就不能实现Eq trait。

这两个trait都可以用derive宏来自动实现。当用derive来实现时，如果要实现Eq trait，那么所有的字段都必须实现Eq，如果包含浮点数这样没有实现Eq的字段，那么是无法实现Eq的。比如下面的代码是无法编译的：

#[derive(Debug, PartialEq, Eq)]
struct Book {
	isbn: String,
	price: f32,
}
1
2
3
4
5

编译器会建议你把price改成i32这种实现了Eq的类型。

PartialOrd, Ord

PartialOrd和Ord这对Trait的应用场景跟PartialEq和Eq非常相似。
PartialOrd用于类型只能部分进行比较的场景，Ord则要求类型所有的部分都能进行比较。
比如上面例子中的浮点类型中的NaN,是不能比较的，所以包含浮点数的类型，就不能实现Ord，只能实现PartialOrd。

pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs>
where
    Rhs: ?Sized,
{
    // Required method
    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

    // Provided methods
    fn lt(&self, other: &Rhs) -> bool { ... }
    fn le(&self, other: &Rhs) -> bool { ... }
    fn gt(&self, other: &Rhs) -> bool { ... }
    fn ge(&self, other: &Rhs) -> bool { ... }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

lt、le、 gt 和 ge可能分别通过 <、<=、 >,和 >= 这些操作符来调用。可见Rust是通过trait来支持操作符重载的。

总结一下，上述的traits在rust里被称为Derivable Traits，中文叫可派生的 trait。这些trait是标准库中定义的，可以通过derive在类型上实现。这些trait具有默认行为，因此可以通过简单的derive宏来自动生成对应的实现代码。Derivable Traits允许程序员轻松地为他们的类型自动生成一些常见trait的实现代码，提高了开发效率并确保了一致性。

本文同时发在我的个人网站上：https://www.renhl.com/posts/2024/02/20/rust-derivable-traits/