泛型

generics.md
commit 23a7a7bdb6a6a43cd7efdd9176b1d3f75d9d0e70

有时，当你编写函数或数据类型时，我们可能会希望它能处理多种类型的参数。幸运的是，Rust有一个能给我们更好选择的功能：泛型。泛型在类型理论中叫做参数多态（parametric polymorphism），它意味着它们是对于给定参数（parametric）能够有多种形式（poly是多，morph是形态）的函数或类型。

不管怎么样，类型理论就说这么多，现在我们来看些泛型代码。Rust 标准库提供了一个范型的类型——Option<T>：

  1. enum Option<T> {
  2.     Some(T),
  3.     None,
  4. }

之前你已见过几次的<T>部分代表它是一个泛型数据类型。在上面的枚举声明中，每当我们看到T，我们用这个类型代替我们泛型中使用的类型。下面是一个使用Option<T>的例子，它带有额外的类型标注：

  1. let x: Option<i32> = Some(5);

在类型声明中，我们看到Option<i32>。注意它与Option<T>的相似之处。在这个特定的Option中，T的值为i32。在绑定的右侧，我们用了Some(T)，其中T是5。因为它是i32型的，两边类型相符，所以皆大欢喜。如果不相符，我们会得到一个错误：

  1. let x: Option<f64> = Some(5);
  2. // error: mismatched types: expected `core::option::Option<f64>`,
  3. // found `core::option::Option<_>` (expected f64 but found integral variable)

这并不意味着我们不能写用f64的Option<T>！只是类型必须相符：

  1. let x: Option<i32> = Some(5);
  2. let y: Option<f64> = Some(5.0f64);

这样就好了。一处定义，到处使用。

不一定只有一个类型是泛型的。想想Rust标准库中另一个类似的Result<T, E>类型：

  1. enum Result<T, E> {
  2.     Ok(T),
  3.     Err(E),
  4. }

这里有两个泛型类型：T和E。另外，大写字母可以是任何你喜欢的（大写）字母。我们可以定义Result<T, E>为：

  1. enum Result<A, Z> {
  2.     Ok(A),
  3.     Err(Z),
  4. }

如果你想这么做的话。惯例告诉我们第一个泛型参数应该是T，代表type，然后我们用E来代表error。然而，Rust 并不管这些。

Result<T, E>意图作为计算的返回值，并为了能够在不能工作时返回一个错误。

泛型函数

我们可以用熟悉的语法编写一个获取泛型参数的函数：

  1. fn takes_anything<T>(x: T) {
  2.     // Do something with `x`.
  3. }

语法有两部分：<T>代表“这个函数带有一个泛型类型”，而x: T代表“x是T类型的”。

多个参数可以有相同的泛型类型：

  1. fn takes_two_of_the_same_things<T>(x: T, y: T) {
  2.     // ...
  3. }

我们可以写一个获取多个（泛型）类型的版本：

  1. fn takes_two_things<T, U>(x: T, y: U) {
  2.     // ...
  3. }

泛型结构体（Generic structs）

你也可以在一个struct中储存泛型类型：

  1. struct Point<T> {
  2.     x: T,
  3.     y: T,
  4. }
  6. let int_origin = Point { x: 0, y: 0 };
  7. let float_origin = Point { x: 0.0, y: 0.0 };

与函数类似，<T>是我们声明的泛型参数，而我们也接着在类型定义中使用x: T。

当你想要给泛型struct增加一个实现时，你可以在impl声明类型参数：

  1. # struct Point<T> {
  2. #     x: T,
  3. #     y: T,
  4. # }
  5. #
  6. impl<T> Point<T> {
  7.     fn swap(&mut self) {
  8.         std::mem::swap(&mut self.x, &mut self.y);
  9.     }
  10. }

目前为止你已经见过了支持几乎任何类型的泛型。他们在很多地方都是有用的：你已经见过了Option<T>，接下来你还将见到像Vec<T>这样的通用容器类型。另一方面，通常你想要用灵活性去换取更强的表现力。阅读trait bound章节来了解为什么和如何做。

消除歧义（Resolving ambiguities）

大部分时候当涉及到泛型时，编译器可以自动推断出泛型参数：

  1. // v must be a Vec<T> but we don't know what T is yet
  2. let mut v = Vec::new();
  3. // v just got a bool value, so T must be bool!
  4. v.push(true);
  5. // Debug-print v
  6. println!("{:?}", v);

但是有的时候，编译器需要一些帮助。例如，如下如果省略最后一行的打印，会得到一个编译错误：

  1. let v = Vec::new();
  2. //      ^^^^^^^^ cannot infer type for `T`
  3. //
  4. // note: type annotations or generic parameter binding required
  5. println!("{:?}", v);

我们要么可以使用一个类型注解来解决它：

  1. let v: Vec<bool> = Vec::new();
  2. println!("{:?}", v);

要么通过一个叫做‘turbofish’ ::<> 的语法来绑定泛型参数T：

  1. let v = Vec::<bool>::new();
  2. println!("{:?}", v);

第二种方法在我们并不想要将结果绑定到一个变量时很有用。它也可以用来在函数和方法中绑定泛型参数。查看迭代器与消费者 章节来获取一个例子。