Rust 常见内置 Traits 详解（一）

原文地址：https://ipotato.me/article/59

本文为《Rust 内置 Traits 详解》系列第一篇，该系列的目的是对 Rust 标准库 std::prelude 中提供的大部分内建 Traits 以适当的篇幅进行解释分析，并辅之以例子（多来自官方文档），旨在帮助读者理解不同 Traits 的使用场景，使用方式及其背后的原因。

本篇作为试水，将包括几个简单的 Traits，均来自于 std::cmp

• Eq & PartialEq

• Ord & PartialOrd

Eq & PartialEq

Eq and PartialEq are traits that allow you to define total and partial equality between values, respectively. Implementing them overloads the == and != operators.

这两个 Traits 的名称实际上来自于抽象代数中的等价关系和局部等价关系，实际上两者的区别仅有一点，即是否在相等比较中是否满足反身性（Reflexivity）。

两者均需要满足的条件有：

• 对称性（Symmetry）：a == b 可推出 b == a

• 传递性（Transitivity）：a == b 且 b == c 可推出 a == c

Eq 相比 PartialEq 需要额外满足反身性，即 a == a，对于浮点类型，Rust 只实现了 PartialEq 而不是 Eq，原因就是 NaN != NaN。

PartialEq 可使用 #[derive] 来交由编译器实现，这样一个 struct 在进行相等比较时，会对其中每一个字段进行比较，如果遇到枚举，还会对枚举所拥有的数据进行比较。你也可以自己实现自己的 PartialEq 方法，例子如下：

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
    }
}

实现时只需要实现 fn eq(&self, other: &Self) -> bool 判断是否相等的函数，Rust 会自动提供 fn ne(&self, other: &Self) -> bool。

实现 Eq 的前提是已经实现了 PartialEq，因为实现 Eq 不需要额外的代码，只需要在实现了 PartialEq 的基础上告诉编译器它的比较满足反身性就可以了。对于上面的例子只需要：#[derive(Eq)] 或 impl Eq for Book {}。

Ord & PartialOrd

Ord and PartialOrd are traits that allow you to define total and partial orderings between values, respectively. Implementing them overloads the <, <=, >, and >= operators.

类似于 Eq，Ord 指的是 Total Order，需要满足以下三个性质：

• 反对称性（Antisymmetry）：a <= b 且 a >= b 可推出 a == b

• 传递性（Transitivity）：a <= b 且 b <= c 可推出 a <= c

• 连通性（Connexity）：a <= b 或 a >= b

而 PartialOrd 无需满足连通性，只满足反对称性和传递性即可。

• 反对称性：a < b 则有 !(a > b)，反之亦然

• 传递性：a < b 且 b < c 可推出 a < c，== 和 > 同理

Ord & PartialOrd 均可通过 #[derive] 交由编译器自动实现，当使用 #[derive] 实现后，将会基于 struct 的字段声明以字典序进行比较，遇到枚举中的数据也会以此类推。可以注意到 Ord & PartialOrd 的性质要求会进行等于的比较，所以有以下对 Eq & PartialEq 的依赖要求：

• PartialOrd 要求你的类型实现 PartialEq

• Ord 要求你的类型实现 PartialOrd 和 Eq（因此 PartialEq 也需要被实现）

实现 PartialEq，PartialOrd 以及 Ord 时要特别注意彼此之间不能有冲突。

use std::cmp::Ordering;

#[derive(Eq)]
struct Person {
    id: u32,
    name: String,
    height: u32,
}

impl Ord for Person {
    fn cmp(&self, other: &Self) -> Ordering {
        self.height.cmp(&other.height)
    }
}

impl PartialOrd for Person {
    fn partial_cmp(&self, other: &Self) -> Option {
        Some(self.cmp(other))
    }
}

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

实现 PartialOrd 需要实现 fn partial_cmp(&self, other: &Self) -> Option，可以注意到这里的返回值是个 Option 枚举，之所以如此是要考虑到与 NaN 作比较的情况：

let result = std::f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);

完成后会为为你的类型提供 lt()，le()，gt() 和 ge() 的比较操作。

而实现 Ord 需要实现 fn cmp(&self, other: &Self) -> Ordering，完成后会为你的类型提供 max() 和 min()。在目前的 Nightly 版本中，实现 Ord 还会提供一个 clamp() 函数，用来比较类型是否在某个区间中。

#![feature(clamp)]

assert!((-3).clamp(-2, 1) == -2);
assert!(0.clamp(-2, 1) == 0);
assert!(2.clamp(-2, 1) == 1);