Trait:定义共同行为

ch10-02-traits.md
commit 3c2ca8528c3b92b7d30e73f2e8a1b84b2f68b0c8

trait 告诉 Rust 编译器某个特定类型拥有可能与其他类型共享的功能。可以通过 trait 以一种抽象的方式定义共享的行为。可以使用 trait bounds 指定泛型是任何拥有特定行为的类型。

注意:trait 类似于其他语言中的常被称为 接口interfaces)的功能,虽然有一些不同。

定义 trait

一个类型的行为由其可供调用的方法构成。如果可以对不同类型调用相同的方法的话,这些类型就可以共享相同的行为了。trait 定义是一种将方法签名组合起来的方法,目的是定义一个实现某些目的所必需的行为的集合。

例如,这里有多个存放了不同类型和属性文本的结构体:结构体 NewsArticle 用于存放发生于世界各地的新闻故事,而结构体 Tweet 最多只能存放 280 个字符的内容,以及像是否转推或是否是对推友的回复这样的元数据。

我们想要创建一个名为 aggregator 的多媒体聚合库用来显示可能储存在 NewsArticleTweet 实例中的数据的总结。每一个结构体都需要的行为是他们是能够被总结的,这样的话就可以调用实例的 summarize 方法来请求总结。示例 10-12 中展示了一个表现这个概念的公有 Summary trait 的定义:

文件名: src/lib.rs

  1. pub trait Summary {
  2. fn summarize(&self) -> String;
  3. }

示例 10-12:Summary trait 定义,它包含由 summarize 方法提供的行为

这里使用 trait 关键字来声明一个 trait,后面是 trait 的名字,在这个例子中是 Summary。我们也声明 traitpub 以便依赖这个 crate 的 crate 也可以使用这个 trait,正如我们见过的一些示例一样。在大括号中声明描述实现这个 trait 的类型所需要的行为的方法签名,在这个例子中是 fn summarize(&self) -> String

在方法签名后跟分号,而不是在大括号中提供其实现。接着每一个实现这个 trait 的类型都需要提供其自定义行为的方法体,编译器也会确保任何实现 Summary trait 的类型都拥有与这个签名的定义完全一致的 summarize 方法。

trait 体中可以有多个方法:一行一个方法签名且都以分号结尾。

为类型实现 trait

现在我们定义了 Summary trait 的签名,接着就可以在多媒体聚合库中实现这个类型了。示例 10-13 中展示了 NewsArticle 结构体上 Summary trait 的一个实现,它使用标题、作者和创建的位置作为 summarize 的返回值。对于 Tweet 结构体,我们选择将 summarize 定义为用户名后跟推文的全部文本作为返回值,并假设推文内容已经被限制为 280 字符以内。

文件名: src/lib.rs

  1. pub trait Summary {
  2. fn summarize(&self) -> String;
  3. }
  4. pub struct NewsArticle {
  5. pub headline: String,
  6. pub location: String,
  7. pub author: String,
  8. pub content: String,
  9. }
  10. impl Summary for NewsArticle {
  11. fn summarize(&self) -> String {
  12. format!("{}, by {} ({})", self.headline, self.author, self.location)
  13. }
  14. }
  15. pub struct Tweet {
  16. pub username: String,
  17. pub content: String,
  18. pub reply: bool,
  19. pub retweet: bool,
  20. }
  21. impl Summary for Tweet {
  22. fn summarize(&self) -> String {
  23. format!("{}: {}", self.username, self.content)
  24. }
  25. }

示例 10-13:在 NewsArticleTweet 类型上实现 Summary trait

在类型上实现 trait 类似于实现与 trait 无关的方法。区别在于 impl 关键字之后,我们提供需要实现 trait 的名称,接着是 for 和需要实现 trait 的类型的名称。在 impl 块中,使用 trait 定义中的方法签名,不过不再后跟分号,而是需要在大括号中编写函数体来为特定类型实现 trait 方法所拥有的行为。

现在库在 NewsArticleTweet 上实现了Summary trait,crate 的用户可以像调用常规方法一样调用 NewsArticleTweet 实例的 trait 方法了。唯一的区别是 trait 必须和类型一起引入作用域以便使用额外的 trait 方法。这是一个二进制 crate 如何利用 aggregator 库 crate 的例子:

  1. use aggregator::{Summary, Tweet};
  2. fn main() {
  3. let tweet = Tweet {
  4. username: String::from("horse_ebooks"),
  5. content: String::from(
  6. "of course, as you probably already know, people",
  7. ),
  8. reply: false,
  9. retweet: false,
  10. };
  11. println!("1 new tweet: {}", tweet.summarize());
  12. }

这会打印出 1 new tweet: horse_ebooks: of course, as you probably already know, people

其他依赖 aggregator crate 的 crate 也可以将 Summary 引入作用域以便为其自己的类型实现该 trait。实现 trait 时需要注意的一个限制是,只有当至少一个 trait 或者要实现 trait 的类型位于 crate 的本地作用域时,才能为该类型实现 trait。例如,可以为 aggregator crate 的自定义类型 Tweet 实现如标准库中的 Display trait,这是因为 Tweet 类型位于 aggregator crate 本地的作用域中。类似地,也可以在 aggregator crate 中为 Vec 实现 Summary,这是因为 Summary trait 位于 aggregator crate 本地作用域中。

但是不能为外部类型实现外部 trait。例如,不能在 aggregator crate 中为 Vec 实现 Display trait。这是因为 DisplayVec 都定义于标准库中,它们并不位于 aggregator crate 本地作用域中。这个限制是被称为 相干性coherence) 的程序属性的一部分,或者更具体的说是 孤儿规则orphan rule),其得名于不存在父类型。这条规则确保了其他人编写的代码不会破坏你代码,反之亦然。没有这条规则的话,两个 crate 可以分别对相同类型实现相同的 trait,而 Rust 将无从得知应该使用哪一个实现。

默认实现

有时为 trait 中的某些或全部方法提供默认的行为,而不是在每个类型的每个实现中都定义自己的行为是很有用的。这样当为某个特定类型实现 trait 时,可以选择保留或重载每个方法的默认行为。

示例 10-14 中展示了如何为 Summary trait 的 summarize 方法指定一个默认的字符串值,而不是像示例 10-12 中那样只是定义方法签名:

文件名: src/lib.rs

  1. pub trait Summary {
  2. fn summarize(&self) -> String {
  3. String::from("(Read more...)")
  4. }
  5. }
  6. pub struct NewsArticle {
  7. pub headline: String,
  8. pub location: String,
  9. pub author: String,
  10. pub content: String,
  11. }
  12. impl Summary for NewsArticle {}
  13. pub struct Tweet {
  14. pub username: String,
  15. pub content: String,
  16. pub reply: bool,
  17. pub retweet: bool,
  18. }
  19. impl Summary for Tweet {
  20. fn summarize(&self) -> String {
  21. format!("{}: {}", self.username, self.content)
  22. }
  23. }

示例 10-14:Summary trait 的定义,带有一个 summarize 方法的默认实现

如果想要对 NewsArticle 实例使用这个默认实现,而不是定义一个自己的实现,则可以通过 impl Summary for NewsArticle {} 指定一个空的 impl 块。

虽然我们不再直接为 NewsArticle 定义 summarize 方法了,但是我们提供了一个默认实现并且指定 NewsArticle 实现 Summary trait。因此,我们仍然可以对 NewsArticle 实例调用 summarize 方法,如下所示:

  1. use chapter10::{self, NewsArticle, Summary};
  2. fn main() {
  3. let article = NewsArticle {
  4. headline: String::from("Penguins win the Stanley Cup Championship!"),
  5. location: String::from("Pittsburgh, PA, USA"),
  6. author: String::from("Iceburgh"),
  7. content: String::from(
  8. "The Pittsburgh Penguins once again are the best \
  9. hockey team in the NHL.",
  10. ),
  11. };
  12. println!("New article available! {}", article.summarize());
  13. }

这段代码会打印 New article available! (Read more…)

summarize 创建默认实现并不要求对示例 10-13 中 Tweet 上的 Summary 实现做任何改变。其原因是重载一个默认实现的语法与实现没有默认实现的 trait 方法的语法一样。

默认实现允许调用相同 trait 中的其他方法,哪怕这些方法没有默认实现。如此,trait 可以提供很多有用的功能而只需要实现指定一小部分内容。例如,我们可以定义 Summary trait,使其具有一个需要实现的 summarize_author 方法,然后定义一个 summarize 方法,此方法的默认实现调用 summarize_author 方法:

  1. pub trait Summary {
  2. fn summarize_author(&self) -> String;
  3. fn summarize(&self) -> String {
  4. format!("(Read more from {}...)", self.summarize_author())
  5. }
  6. }
  7. pub struct Tweet {
  8. pub username: String,
  9. pub content: String,
  10. pub reply: bool,
  11. pub retweet: bool,
  12. }
  13. impl Summary for Tweet {
  14. fn summarize_author(&self) -> String {
  15. format!("@{}", self.username)
  16. }
  17. }

为了使用这个版本的 Summary,只需在实现 trait 时定义 summarize_author 即可:

  1. pub trait Summary {
  2. fn summarize_author(&self) -> String;
  3. fn summarize(&self) -> String {
  4. format!("(Read more from {}...)", self.summarize_author())
  5. }
  6. }
  7. pub struct Tweet {
  8. pub username: String,
  9. pub content: String,
  10. pub reply: bool,
  11. pub retweet: bool,
  12. }
  13. impl Summary for Tweet {
  14. fn summarize_author(&self) -> String {
  15. format!("@{}", self.username)
  16. }
  17. }

一旦定义了 summarize_author,我们就可以对 Tweet 结构体的实例调用 summarize 了,而 summarize 的默认实现会调用我们提供的 summarize_author 定义。因为实现了 summarize_authorSummary trait 就提供了 summarize 方法的功能,且无需编写更多的代码。

  1. use chapter10::{self, Summary, Tweet};
  2. fn main() {
  3. let tweet = Tweet {
  4. username: String::from("horse_ebooks"),
  5. content: String::from(
  6. "of course, as you probably already know, people",
  7. ),
  8. reply: false,
  9. retweet: false,
  10. };
  11. println!("1 new tweet: {}", tweet.summarize());
  12. }

这会打印出 1 new tweet: (Read more from @horse_ebooks…)

注意无法从相同方法的重载实现中调用默认方法。

trait 作为参数

知道了如何定义 trait 和在类型上实现这些 trait 之后,我们可以探索一下如何使用 trait 来接受多种不同类型的参数。

例如在示例 10-13 中为 NewsArticleTweet 类型实现了 Summary trait。我们可以定义一个函数 notify 来调用其参数 item 上的 summarize 方法,该参数是实现了 Summary trait 的某种类型。为此可以使用 impl Trait 语法,像这样:

  1. pub trait Summary {
  2. fn summarize(&self) -> String;
  3. }
  4. pub struct NewsArticle {
  5. pub headline: String,
  6. pub location: String,
  7. pub author: String,
  8. pub content: String,
  9. }
  10. impl Summary for NewsArticle {
  11. fn summarize(&self) -> String {
  12. format!("{}, by {} ({})", self.headline, self.author, self.location)
  13. }
  14. }
  15. pub struct Tweet {
  16. pub username: String,
  17. pub content: String,
  18. pub reply: bool,
  19. pub retweet: bool,
  20. }
  21. impl Summary for Tweet {
  22. fn summarize(&self) -> String {
  23. format!("{}: {}", self.username, self.content)
  24. }
  25. }
  26. pub fn notify(item: &impl Summary) {
  27. println!("Breaking news! {}", item.summarize());
  28. }

对于 item 参数,我们指定了 impl 关键字和 trait 名称,而不是具体的类型。该参数支持任何实现了指定 trait 的类型。在 notify 函数体中,可以调用任何来自 Summary trait 的方法,比如 summarize。我们可以传递任何 NewsArticleTweet 的实例来调用 notify。任何用其它如 Stringi32 的类型调用该函数的代码都不能编译,因为它们没有实现 Summary

Trait Bound 语法

impl Trait 语法适用于直观的例子,它实际上是一种较长形式语法的语法糖。我们称为 trait bound,它看起来像:

  1. pub fn notify<T: Summary>(item: &T) {
  2. println!("Breaking news! {}", item.summarize());
  3. }

这与之前的例子相同,不过稍微冗长了一些。trait bound 与泛型参数声明在一起,位于尖括号中的冒号后面。

impl Trait 很方便,适用于短小的例子。trait bound 则适用于更复杂的场景。例如,可以获取两个实现了 Summary 的参数。使用 impl Trait 的语法看起来像这样:

  1. pub fn notify(item1: &impl Summary, item2: &impl Summary) {

这适用于 item1item2 允许是不同类型的情况(只要它们都实现了 Summary)。不过如果你希望强制它们都是相同类型呢?这只有在使用 trait bound 时才有可能:

  1. pub fn notify<T: Summary>(item1: &T, item2: &T) {

泛型 T 被指定为 item1item2 的参数限制,如此传递给参数 item1item2 值的具体类型必须一致。

通过 + 指定多个 trait bound

如果 notify 需要显示 item 的格式化形式,同时也要使用 summarize 方法,那么 item 就需要同时实现两个不同的 trait:DisplaySummary。这可以通过 + 语法实现:

  1. pub fn notify(item: &(impl Summary + Display)) {

+ 语法也适用于泛型的 trait bound:

  1. pub fn notify<T: Summary + Display>(item: &T) {

通过指定这两个 trait bound,notify 的函数体可以调用 summarize 并使用 {} 来格式化 item

通过 where 简化 trait bound

然而,使用过多的 trait bound 也有缺点。每个泛型有其自己的 trait bound,所以有多个泛型参数的函数在名称和参数列表之间会有很长的 trait bound 信息,这使得函数签名难以阅读。为此,Rust 有另一个在函数签名之后的 where 从句中指定 trait bound 的语法。所以除了这么写:

  1. fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

还可以像这样使用 where 从句:

  1. fn some_function<T, U>(t: &T, u: &U) -> i32
  2. where T: Display + Clone,
  3. U: Clone + Debug
  4. {

这个函数签名就显得不那么杂乱,函数名、参数列表和返回值类型都离得很近,看起来跟没有那么多 trait bounds 的函数很像。

返回实现了 trait 的类型

也可以在返回值中使用 impl Trait 语法,来返回实现了某个 trait 的类型:

  1. pub trait Summary {
  2. fn summarize(&self) -> String;
  3. }
  4. pub struct NewsArticle {
  5. pub headline: String,
  6. pub location: String,
  7. pub author: String,
  8. pub content: String,
  9. }
  10. impl Summary for NewsArticle {
  11. fn summarize(&self) -> String {
  12. format!("{}, by {} ({})", self.headline, self.author, self.location)
  13. }
  14. }
  15. pub struct Tweet {
  16. pub username: String,
  17. pub content: String,
  18. pub reply: bool,
  19. pub retweet: bool,
  20. }
  21. impl Summary for Tweet {
  22. fn summarize(&self) -> String {
  23. format!("{}: {}", self.username, self.content)
  24. }
  25. }
  26. fn returns_summarizable() -> impl Summary {
  27. Tweet {
  28. username: String::from("horse_ebooks"),
  29. content: String::from(
  30. "of course, as you probably already know, people",
  31. ),
  32. reply: false,
  33. retweet: false,
  34. }
  35. }

通过使用 impl Summary 作为返回值类型,我们指定了 returns_summarizable 函数返回某个实现了 Summary trait 的类型,但是不确定其具体的类型。在这个例子中 returns_summarizable 返回了一个 Tweet,不过调用方并不知情。

返回一个只是指定了需要实现的 trait 的类型的能力在闭包和迭代器场景十分的有用,第十三章会介绍它们。闭包和迭代器创建只有编译器知道的类型,或者是非常非常长的类型。impl Trait 允许你简单的指定函数返回一个 Iterator 而无需写出实际的冗长的类型。

不过这只适用于返回单一类型的情况。例如,这段代码的返回值类型指定为返回 impl Summary,但是返回了 NewsArticleTweet 就行不通:

  1. pub trait Summary {
  2. fn summarize(&self) -> String;
  3. }
  4. pub struct NewsArticle {
  5. pub headline: String,
  6. pub location: String,
  7. pub author: String,
  8. pub content: String,
  9. }
  10. impl Summary for NewsArticle {
  11. fn summarize(&self) -> String {
  12. format!("{}, by {} ({})", self.headline, self.author, self.location)
  13. }
  14. }
  15. pub struct Tweet {
  16. pub username: String,
  17. pub content: String,
  18. pub reply: bool,
  19. pub retweet: bool,
  20. }
  21. impl Summary for Tweet {
  22. fn summarize(&self) -> String {
  23. format!("{}: {}", self.username, self.content)
  24. }
  25. }
  26. fn returns_summarizable(switch: bool) -> impl Summary {
  27. if switch {
  28. NewsArticle {
  29. headline: String::from(
  30. "Penguins win the Stanley Cup Championship!",
  31. ),
  32. location: String::from("Pittsburgh, PA, USA"),
  33. author: String::from("Iceburgh"),
  34. content: String::from(
  35. "The Pittsburgh Penguins once again are the best \
  36. hockey team in the NHL.",
  37. ),
  38. }
  39. } else {
  40. Tweet {
  41. username: String::from("horse_ebooks"),
  42. content: String::from(
  43. "of course, as you probably already know, people",
  44. ),
  45. reply: false,
  46. retweet: false,
  47. }
  48. }
  49. }

这里尝试返回 NewsArticleTweet。这不能编译,因为 impl Trait 工作方式的限制。第十七章的 “为使用不同类型的值而设计的 trait 对象” 部分会介绍如何编写这样一个函数。

使用 trait bounds 来修复 largest 函数

现在你知道了如何使用泛型参数 trait bound 来指定所需的行为。让我们回到实例 10-5 修复使用泛型类型参数的 largest 函数定义!回顾一下,最后尝试编译代码时出现的错误是:

  1. $ cargo run
  2. Compiling chapter10 v0.1.0 (file:///projects/chapter10)
  3. error[E0369]: binary operation `>` cannot be applied to type `T`
  4. --> src/main.rs:5:17
  5. |
  6. 5 | if item > largest {
  7. | ---- ^ ------- T
  8. | |
  9. | T
  10. |
  11. help: consider restricting type parameter `T`
  12. |
  13. 1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
  14. | ++++++++++++++++++++++
  15. For more information about this error, try `rustc --explain E0369`.
  16. error: could not compile `chapter10` due to previous error

largest 函数体中我们想要使用大于运算符(>)比较两个 T 类型的值。这个运算符被定义为标准库中 trait std::cmp::PartialOrd 的一个默认方法。所以需要在 T 的 trait bound 中指定 PartialOrd,这样 largest 函数可以用于任何可以比较大小的类型的 slice。因为 PartialOrd 位于 prelude 中所以并不需要手动将其引入作用域。将 largest 的签名修改为如下:

  1. fn largest<T: PartialOrd>(list: &[T]) -> T {
  2. let mut largest = list[0];
  3. for &item in list {
  4. if item > largest {
  5. largest = item;
  6. }
  7. }
  8. largest
  9. }
  10. fn main() {
  11. let number_list = vec![34, 50, 25, 100, 65];
  12. let result = largest(&number_list);
  13. println!("The largest number is {}", result);
  14. let char_list = vec!['y', 'm', 'a', 'q'];
  15. let result = largest(&char_list);
  16. println!("The largest char is {}", result);
  17. }

但是如果编译代码的话,会出现一些不同的错误:

  1. $ cargo run
  2. Compiling chapter10 v0.1.0 (file:///projects/chapter10)
  3. error[E0508]: cannot move out of type `[T]`, a non-copy slice
  4. --> src/main.rs:2:23
  5. |
  6. 2 | let mut largest = list[0];
  7. | ^^^^^^^
  8. | |
  9. | cannot move out of here
  10. | move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
  11. | help: consider borrowing here: `&list[0]`
  12. error[E0507]: cannot move out of a shared reference
  13. --> src/main.rs:4:18
  14. |
  15. 4 | for &item in list {
  16. | ----- ^^^^
  17. | ||
  18. | |data moved here
  19. | |move occurs because `item` has type `T`, which does not implement the `Copy` trait
  20. | help: consider removing the `&`: `item`
  21. Some errors have detailed explanations: E0507, E0508.
  22. For more information about an error, try `rustc --explain E0507`.
  23. error: could not compile `chapter10` due to 2 previous errors

错误的核心是 cannot move out of type [T], a non-copy slice,对于非泛型版本的 largest 函数,我们只尝试了寻找最大的 i32char。正如第四章 “只在栈上的数据:拷贝” 部分讨论过的,像 i32char 这样的类型是已知大小的并可以储存在栈上,所以他们实现了 Copy trait。当我们将 largest 函数改成使用泛型后,现在 list 参数的类型就有可能是没有实现 Copy trait 的。这意味着我们可能不能将 list[0] 的值移动到 largest 变量中,这导致了上面的错误。

为了只对实现了 Copy 的类型调用这些代码,可以在 T 的 trait bounds 中增加 Copy!示例 10-15 中展示了一个可以编译的泛型版本的 largest 函数的完整代码,只要传递给 largest 的 slice 值的类型实现了 PartialOrd Copy 这两个 trait,例如 i32char

文件名: src/main.rs

  1. fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
  2. let mut largest = list[0];
  3. for &item in list {
  4. if item > largest {
  5. largest = item;
  6. }
  7. }
  8. largest
  9. }
  10. fn main() {
  11. let number_list = vec![34, 50, 25, 100, 65];
  12. let result = largest(&number_list);
  13. println!("The largest number is {}", result);
  14. let char_list = vec!['y', 'm', 'a', 'q'];
  15. let result = largest(&char_list);
  16. println!("The largest char is {}", result);
  17. }

示例 10-15:一个可以用于任何实现了 PartialOrdCopy trait 的泛型的 largest 函数

如果并不希望限制 largest 函数只能用于实现了 Copy trait 的类型,我们可以在 T 的 trait bounds 中指定 Clone 而不是 Copy。并克隆 slice 的每一个值使得 largest 函数拥有其所有权。使用 clone 函数意味着对于类似 String 这样拥有堆上数据的类型,会潜在的分配更多堆上空间,而堆分配在涉及大量数据时可能会相当缓慢。

另一种 largest 的实现方式是返回在 slice 中 T 值的引用。如果我们将函数返回值从 T 改为 &T 并改变函数体使其能够返回一个引用,我们将不需要任何 CloneCopy 的 trait bounds 而且也不会有任何的堆分配。尝试自己实现这种替代解决方式吧!如果你无法摆脱与生命周期有关的错误,请继续阅读:接下来的 “生命周期与引用有效性” 部分会详细的说明,不过生命周期对于解决这些挑战来说并不是必须的。

使用 trait bound 有条件地实现方法

通过使用带有 trait bound 的泛型参数的 impl 块,可以有条件地只为那些实现了特定 trait 的类型实现方法。例如,示例 10-16 中的类型 Pair 总是实现了 new 方法并返回一个 Pair 的实例(回忆一下第五章的 "定义方法" 部分,Self 是一个 impl 块类型的类型别名(type alias),在这里是 Pair)。不过在下一个 impl 块中,只有那些为 T 类型实现了 PartialOrd trait (来允许比较) Display trait (来启用打印)的 Pair 才会实现 cmp_display 方法:

  1. use std::fmt::Display;
  2. struct Pair<T> {
  3. x: T,
  4. y: T,
  5. }
  6. impl<T> Pair<T> {
  7. fn new(x: T, y: T) -> Self {
  8. Self { x, y }
  9. }
  10. }
  11. impl<T: Display + PartialOrd> Pair<T> {
  12. fn cmp_display(&self) {
  13. if self.x >= self.y {
  14. println!("The largest member is x = {}", self.x);
  15. } else {
  16. println!("The largest member is y = {}", self.y);
  17. }
  18. }
  19. }

示例 10-16:根据 trait bound 在泛型上有条件的实现方法

也可以对任何实现了特定 trait 的类型有条件地实现 trait。对任何满足特定 trait bound 的类型实现 trait 被称为 blanket implementations,他们被广泛的用于 Rust 标准库中。例如,标准库为任何实现了 Display trait 的类型实现了 ToString trait。这个 impl 块看起来像这样:

  1. impl<T: Display> ToString for T {
  2. // --snip--
  3. }

因为标准库有了这些 blanket implementation,我们可以对任何实现了 Display trait 的类型调用由 ToString 定义的 to_string 方法。例如,可以将整型转换为对应的 String 值,因为整型实现了 Display

  1. #![allow(unused)]
  2. fn main() {
  3. let s = 3.to_string();
  4. }

blanket implementation 会出现在 trait 文档的 “Implementers” 部分。

trait 和 trait bound 让我们使用泛型类型参数来减少重复,并仍然能够向编译器明确指定泛型类型需要拥有哪些行为。因为我们向编译器提供了 trait bound 信息,它就可以检查代码中所用到的具体类型是否提供了正确的行为。在动态类型语言中,如果我们尝试调用一个类型并没有实现的方法,会在运行时出现错误。Rust 将这些错误移动到了编译时,甚至在代码能够运行之前就强迫我们修复错误。另外,我们也无需编写运行时检查行为的代码,因为在编译时就已经检查过了,这样相比其他那些不愿放弃泛型灵活性的语言有更好的性能。

这里还有一种泛型,我们一直在使用它甚至都没有察觉它的存在,这就是 生命周期lifetimes)。不同于其他泛型帮助我们确保类型拥有期望的行为,生命周期则有助于确保引用在我们需要他们的时候一直有效。让我们学习生命周期是如何做到这些的。