2.2.2 实现常见 Trait on 编程那些事儿

2.2.2.1 Debug

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/debug.html

2.2.2.1 Debug

用于调试目的的“写入字符串” trait。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
pub struct Date {
 day: u8,
 month: u8,
 year: i64,
}

#[derive(Debug)]
pub struct User {
 name: String,
 date_of_birth: Date,
}

pub struct PlainTextPassword {
 password: String,
 hint: String,
}

impl std::fmt::Debug for PlainTextPassword {
 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 f.debug_struct("PlainTextPassword")
 .field("hint", &self.hint)
 .field("password", &"[omitted]")
 .finish()
 }
}

fn main() {
 let user = User {
 name: "Alice".to_string(),
 date_of_birth: Date { day: 31, month: 10, year: 2002 },
 };

 println!("{user:?}");
 println!(
 "{:?}",
 PlainTextPassword {
 password: "Password123".to_string(),
 hint: "Used it for years".to_string()
 }
 );
}

提供平凡的“写入字符串”功能。

2.2.2.2 Display

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/display.html

2.2.2.2 Display

“写入字符串” trait，优先考虑终端用户的可读性。

可派生：❌，除非使用 derive_more 之类 crate。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
pub enum NetworkError {
 HttpCode(u16),
 WhaleBitTheUnderseaCable,
}

impl std::fmt::Display for NetworkError {
 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 match self {
 NetworkError::HttpCode(code) => write!(f, "HTTP Error code {code}"),
 NetworkError::WhaleBitTheUnderseaCable => {
 write!(f, "Whale attack detected – call Ishmael")
 }
 }
 }
}

fn main() {
 let http = NetworkError::HttpCode(404);
 let whale = NetworkError::WhaleBitTheUnderseaCable;

 println!("http debug: {:?}", http);
 println!("http display: {}", http);
 println!("whale debug: {:?}", whale);
 println!("whale display: {}", whale);
}

类似 Debug 的 trait，但聚焦于终端用户可读性。

2.2.2.3 PartialEq 与 Eq

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/partialeq-eq.html

2.2.2.3 PartialEq 与 Eq

偏等（partial equality）与全等（total equality）。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(PartialEq, Eq)]
pub struct User { name: String, favorite_number: i32 }

fn main() {
 let alice = User { name: "alice".to_string(), favorite_number: 1_000_042 };
 let bob = User { name: "bob".to_string(), favorite_number: 42 };

 dbg!(alice == alice);
 dbg!(alice == bob);
}

与相等性相关的方法。若类型实现了 PartialEq，则可用 ==/!= 运算符。

2.2.2.4 PartialOrd 与 Ord

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/partialord-ord.html

2.2.2.4 PartialOrd 与 Ord

偏序（partial ordering）与全序（total ordering）。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(PartialEq, PartialOrd)]
pub struct Partially(f32);

#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct Totally {
 id: u32,
 name: String,
}

fn main() {
 let a = Totally { id: 0, name: "alice".into() };
 let b = Totally { id: 1, name: "alice".into() };
 let c = Totally { id: 0, name: "charlie".into() };

 dbg!(a.cmp(&b));
 dbg!(a.cmp(&c));
}

与比较相关的方法。若类型实现了 PartialOrd/Ord，则可用比较运算符（<、<=、>、>=）。

2.2.2.5 Hash

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/hash.html

2.2.2.5 Hash

对类型执行哈希。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::collections::HashMap;

#[derive(PartialEq, Eq, Hash)]
pub struct User {
 id: u32,
 name: String,
}

fn main() {
 let user = User { id: 1, name: "Alice".into() };
 let mut map = HashMap::new();
 map.insert(user, "value");
}

允许类型用于哈希算法，最常与 HashMap 等数据结构一起使用。

2.2.2.6 Clone

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/clone.html

2.2.2.6 Clone

深拷贝类型，或复制可共享的智能指针。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::collections::BTreeSet;
use std::rc::Rc;

#[derive(Clone)]
pub struct LotsOfData {
 string: String,
 vec: Vec<u8>,
 set: BTreeSet<u8>,
}

fn main() {
 let lots_of_data = LotsOfData {
 string: "String".to_string(),
 vec: vec![1; 255],
 set: BTreeSet::from_iter([1, 2, 3, 4, 5, 6, 7, 8]),
 };

 // 深拷贝 `lots_of_data` 中的所有数据。
 let lots_of_data_cloned = lots_of_data.clone();

 let reference_counted = Rc::new(lots_of_data);

 // 复制引用计数指针，而非值本身。
 let reference_copied = reference_counted.clone();
}

“深拷贝”一个值；或在 Rc/Arc 这类引用计数指针的情况下，创建该指针的新实例。

2.2.2.7 Copy

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/copy.html

2.2.2.7 Copy

类似 Clone，但表示类型可按位复制。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug, Clone, Copy)]
pub struct Copyable(u8, u16, u32, u64);

fn main() {
 let copyable = Copyable(1, 2, 3, 4);
 let copy = copyable; // 隐式复制操作
 dbg!(copyable);
 dbg!(copy);
}

Clone 表示显式的、用户定义的复制操作。Copy 表示隐式的按位复制。

2.2.2.8 From 与 Into

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/from-into.html

2.2.2.8 From 与 Into

从一种类型转换到另一种类型。

可派生：❌，除非使用 derive_more 之类 crate。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct Wrapper(String);

impl From<&str> for Wrapper {
 fn from(value: &str) -> Self {
 Wrapper(value.to_owned())
 }
}

impl From<i32> for Wrapper {
 fn from(value: i32) -> Self {
 Wrapper(value.to_string())
 }
}

// `Into` 作为 trait bound 用起来更自然。
fn into_string<S: Into<String>>(s: S) {}
fn string_from<T>(t: T) where String: From<T> {}

fn main() {
 // `Wrapper` 可从 `&str` 和 `i32` 构造。
 let a = Wrapper::from("Hello, obvious!");
 let b = Wrapper::from(-123);

 // From 实现隐含 Into 实现。
 let c: Wrapper = "Hello, implementation!".into();
}

为类型提供转换功能。

2.2.2.9 TryFrom 与 TryInto

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/try-from-into.html

2.2.2.9 TryFrom 与 TryInto

从一种类型到另一种类型的可失败转换。

可派生：❌

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
pub struct InvalidNumber;

#[derive(Debug)]
pub struct DivisibleByTwo(usize);

impl TryFrom<usize> for DivisibleByTwo {
 type Error = InvalidNumber;

 fn try_from(value: usize) -> Result<Self, InvalidNumber> {
 if value.rem_euclid(2) == 0 {
 Ok(DivisibleByTwo(value))
 } else {
 Err(InvalidNumber)
 }
 }
}

fn main() {
 let success: Result<DivisibleByTwo, _> = 4.try_into();
 dbg!(success);
 let fail: Result<DivisibleByTwo, _> = 5.try_into();
 dbg!(fail);
}

提供可能失败的转换，返回 result 类型。

2.2.2.10 Serialize 与 Deserialize

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/common-traits/serde.html

2.2.2.10 Serialize 与 Deserialize

像 serde 这样的 crate 可自动实现序列化。

可派生：✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Serialize, Deserialize)]
struct ExtraData {
 fav_color: String,
 name_of_dog: String,
}

#[derive(Serialize, Deserialize)]
struct Data {
 name: String,
 age: usize,
 extra_data: ExtraData,
}

为类型提供序列化与反序列化功能，使 Rust 数据类型可与 JSON 等数据格式互相转换。