4.1 要点回顾 on 编程那些事儿

4.1.1 Trait

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/traits.html

4.1.1 Trait

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


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
trait Receiver {
 fn send(&self, message: &str);
}

struct EmailAddress(String);

impl Receiver for EmailAddress {
 fn send(&self, message: &str) {
 println!("Email to {}: {}", self.0, message);
 }
}

struct ChatId {
 uuid: [u8; 16],
}

impl Receiver for ChatId {
 fn send(&self, message: &str) {
 println!("Chat message sent to {:?}: {}", self.uuid, message);
 }
}

Rust 的多态与泛型概念很大程度上围绕 trait 展开。

4.1.2 Trait 约束

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/trait-bounds.html

4.1.2 Trait 约束

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


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::fmt::Display;

fn print_with_length<T: Display>(item: T) {
 println!("Item: {}", item);
 println!("Length: {}", item.to_string().len());
}

fn main() {
 let number = 42;
 let text = "Hello, Rust!";

 print_with_length(number); // 可用于整数
 print_with_length(text); // 可用于字符串
}

Trait 最常见的用途，是作为函数或方法上泛型类型参数的约束（bound）。

4.1.3 派生 Trait

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/deriving-traits.html

4.1.3 派生 Trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct BufferId([u8; 16]);

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct DrawingBuffer {
 target: [u8; 16],
 commands: Vec<String>,
}

许多 trait、协议、接口都有平凡的实现，用机械方式写出来很容易。

4.1.4 默认实现

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/default-impls.html

4.1.4 默认实现

 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
pub trait CollectLeaves {
 type Leaf;

 // 必需方法
 fn collect_leaves_buffered(&self, buf: &mut Vec<Self::Leaf>);

 // 默认实现
 fn collect_leaves(&self) -> Vec<Self::Leaf> {
 let mut buf = vec![];
 self.collect_leaves_buffered(&mut buf);
 buf
 }
}

Trait 常有一些方法：只要你实现了必需方法，其余就会替你实现好。

4.1.5 父 Trait（Supertrait）

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/supertraits.html

4.1.5 父 Trait（Supertrait）

Trait 可以由新的 trait 扩展。

 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
pub trait Animal {
 /* 所有动物共有的方法 */
}

pub trait Mammal: Animal {
 /* 仅哺乳动物才有的方法 */
}

// 来自标准库

pub trait Ord: Eq + PartialOrd {
 /* Ord 的方法 */
}

编写 trait 时，可以指定类型还必须实现的其它 trait。这些称为 父 trait（supertrait）。

4.1.6 覆盖式实现（Blanket Impl）

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/blanket-impls.html

4.1.6 覆盖式实现（Blanket Impl）

当 trait 是本地的时，我们可以为任意多的类型实现它。能做到什么程度？

 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
pub trait PrettyPrint {
 fn pretty_print(&self);
}

// 覆盖式实现！凡实现 Display 的类型，都实现 PrettyPrint。
impl<T> PrettyPrint for T
where
 T: std::fmt::Display,
{
 fn pretty_print(&self) {
 println!("{self}")
 }
}

在 trait 定义处，实现的主体可以是任何东西，包括无约束的 T。

4.1.7 条件方法

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/conditional-methods.html

4.1.7 条件方法

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


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// 类型定义上不加 trait 约束。
pub struct Value<T>(T);

// 约束放在该类型的实现上。
impl<T: std::fmt::Display> Value<T> {
 fn log(&self) {
 println!("{}", self.0);
 }
}

// 另一种写法
impl<T> Value<T> {
 // 在 where 表达式中指定 trait 约束
 fn log_error(&self)
 where
 T: std::error::Error,
 {
 eprintln!("{}", self.0);
 }
}

编写带泛型参数的类型时，可以为该类型写出依赖参数本身或其实现哪些 trait 的实现。

4.1.8 孤儿规则

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/orphan-rule.html

4.1.8 孤儿规则

是什么阻止用户为任意类型编写任意 trait 实现？

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


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// crate `postgresql-bindings`

pub struct PostgresqlConn(/* details */);

// crate `database-traits`，依赖 `postgresql-bindings`

pub trait DbConnection {
 /* methods */
}

impl DbConnection for PostgresqlConn {} // ✅，`DbConnection` 是本地的。

// crate `mycoolnewdb` 依赖 `database-traits`

pub struct MyCoolNewDbConn(/* details */);

impl DbConnection for MyCoolNewDbConn {} // ✅，`MyCoolNewDbConn` 是本地的。

// `PostgresqlConn` 与 `DbConnection` 对 `mycoolnewdb` 都不是本地的。
// 这会导致 PostgresqlConn 上出现两份 `DbConnection` 实现！
impl DbConnection for PostgresqlConn {} // ❌🔨

Rust 的 trait 在整个生态中绝不应该被实现两次。同一 trait 对同一类型的两份实现是无法解决的冲突。

4.1.9 静态大小与动态大小类型

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/sized.html

4.1.9 静态大小与动态大小类型

1
2
3
4
5
6
7
8
9


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::fmt::Debug;

pub struct AlwaysSized<T /* : Sized */>(T);

pub struct OptionallySized<T: ?Sized>(T);

type Dyn1 = OptionallySized<dyn Debug>;

动机：能够区分「大小在编译期已知」与「大小在运行时已知」的类型，是有用的。

4.1.10 单态化与二进制体积

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/refresher/monomorphization.html

4.1.10 单态化与二进制体积

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


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn print_vec<T: std::fmt::Debug>(debug_vec: &Vec<T>) {
 for item in debug_vec {
 println!("{:?}", item);
 }
}

fn main() {
 let ints = vec![1u32, 2, 3];
 let floats = vec![1.1f32, 2.2, 3.3];

 // 实例一，&Vec<u32> -> ()
 print_vec(&ints);
 // 实例二，&Vec<f32> -> ()
 print_vec(&floats);
}

带泛型的函数或类型的每一个实例，都会在编译期变成该函数的唯一、具体版本。运行时不存在泛型，只有具体类型。