4 泛型 on 编程那些事儿

4.1 泛型函数

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/generics/generic-functions.html

4.1 泛型函数

Rust 支持泛型（generics），让你可以对所用或所存的类型抽象算法或数据结构（例如排序或二叉树）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn pick<T>(cond: bool, left: T, right: T) -> T {
 if cond { left } else { right }
}

fn main() {
 println!("picked a number: {:?}", pick(true, 222, 333));
 println!("picked a string: {:?}", pick(false, 'L', 'R'));
}

展示 pick 的单态化（monomorphized）版本会有帮助：可以在讲泛型 pick 之前展示，以说明泛型如何减少代码重复；也可以在讲完泛型之后展示，以说明单态化如何工作。

4.2 Trait 约束

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

译文 · 基于 Comprehensive Rust

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

4.2 Trait 约束

使用泛型时，常常希望要求类型实现某个 trait，以便调用该 trait 的方法。

可以用 T: Trait 做到：

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


// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn duplicate<T: Clone>(a: T) -> (T, T) {
 (a.clone(), a.clone())
}

struct NotCloneable;

fn main() {
 let foo = String::from("foo");
 let pair = duplicate(foo);
 println!("{pair:?}");
}

试着构造一个 NotCloneable 并传给 duplicate。

4.3 泛型数据类型

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/generics/generic-data.html

4.3 泛型数据类型

可以用泛型对具体字段类型做抽象。回到上一节的练习：

 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


// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub trait Logger {
 /// 在给定详细级别记录一条消息。
 fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
 fn log(&self, verbosity: u8, message: &str) {
 eprintln!("verbosity={verbosity}: {message}");
 }
}

/// 只记录不超过给定详细级别的消息。
struct VerbosityFilter<L> {
 max_verbosity: u8,
 inner: L,
}

impl<L: Logger> Logger for VerbosityFilter<L> {
 fn log(&self, verbosity: u8, message: &str) {
 if verbosity <= self.max_verbosity {
 self.inner.log(verbosity, message);
 }
 }
}

fn main() {
 let logger = VerbosityFilter { max_verbosity: 3, inner: StderrLogger };
 logger.log(5, "FYI");
 logger.log(2, "Uhoh");
}

问：为什么 impl<L: Logger> .. VerbosityFilter<L> 里 L 写了两次？这不是冗余吗？

因为这是泛型类型的泛型实现段。它们各自独立地泛型。

意思是：这些方法对任意 L 都有定义。

也可以写 impl VerbosityFilter<StderrLogger> { .. }。

VerbosityFilter 仍然是泛型的，你仍可用 VerbosityFilter<f64>，但该块中的方法只对 VerbosityFilter<StderrLogger> 可用。

注意我们没有在 VerbosityFilter 类型本身上放 trait 约束。也可以把约束放在那里，但在 Rust 中一般只把 trait 约束放在 impl 块上。

4.4 泛型 Trait

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/generics/generic-traits.html

4.4 泛型 Trait

Trait 也可以是泛型的，就像类型与函数一样。Trait 的参数在使用时会变成具体类型。例如 From<T> trait 用于定义类型转换：

1
2
3
4
5


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub trait From<T>: Sized {
 fn from(value: T) -> Self;
}

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


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
#[derive(Debug)]
struct Foo(String);

impl From<u32> for Foo {
 fn from(from: u32) -> Foo {
 Foo(format!("Converted from integer: {from}"))
 }
}

impl From<bool> for Foo {
 fn from(from: bool) -> Foo {
 Foo(format!("Converted from bool: {from}"))
 }
}

fn main() {
 let from_int = Foo::from(123);
 let from_bool = Foo::from(true);
 dbg!(from_int);
 dbg!(from_bool);
}

From trait 会在课程后面介绍，但其 std 文档中的定义很简单，这里复制出来作参考。

4.5 `impl Trait`

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/generics/impl-trait.html

4.5 `impl Trait`

与 trait 约束类似，impl Trait 语法可用在函数参数与返回值中：

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


// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0
// 以下写法的语法糖：
// fn add_42_millions<T: Into<i32>>(x: T) -> i32 {
fn add_42_millions(x: impl Into<i32>) -> i32 {
 x.into() + 42_000_000
}

fn pair_of(x: u32) -> impl std::fmt::Debug {
 (x + 1, x - 1)
}

fn main() {
 let many = add_42_millions(42_i8);
 dbg!(many);
 let many_more = add_42_millions(10_000_000);
 dbg!(many_more);
 let debuggable = pair_of(27);
 dbg!(debuggable);
}

impl Trait 让你能使用无法命名的类型。在不同位置，impl Trait 的含义略有不同。

4.6 `dyn Trait`

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

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/generics/dyn-trait.html

4.6 `dyn Trait`

除了通过泛型用 trait 做静态分发外，Rust 还支持通过 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
45
46


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
struct Dog {
 name: String,
 age: i8,
}
struct Cat {
 lives: i8,
}

trait Pet {
 fn talk(&self) -> String;
}

impl Pet for Dog {
 fn talk(&self) -> String {
 format!("Woof, my name is {}!", self.name)
 }
}

impl Pet for Cat {
 fn talk(&self) -> String {
 String::from("Miau!")
 }
}

// 使用泛型与静态分发。
fn generic(pet: &impl Pet) {
 println!("Hello, who are you? {}", pet.talk());
}

// 使用类型擦除与动态分发。
fn dynamic(pet: &dyn Pet) {
 println!("Hello, who are you? {}", pet.talk());
}

fn main() {
 let cat = Cat { lives: 9 };
 let dog = Dog { name: String::from("Fido"), age: 5 };

 generic(&cat);
 generic(&dog);

 dynamic(&cat);
 dynamic(&dog);
}

泛型（包括 impl Trait）通过单态化为每个不同的实例化类型生成专用函数版本。这意味着在泛型函数内调用 trait 方法仍使用静态分发，因为编译器有完整类型信息，并能解析应使用该类型的哪个 trait 实现。

4 泛型 on 编程那些事儿

4.1 泛型函数

4.1 泛型函数

4.2 Trait 约束

4.2 Trait 约束

4.3 泛型数据类型

4.3 泛型数据类型

4.4 泛型 Trait

4.4 泛型 Trait

4.5 `impl Trait`

4.5 impl Trait

4.6 `dyn Trait`

4.6 dyn Trait

4.5 `impl Trait`

4.6 `dyn Trait`