使用泛型的位置

不仅仅是函数的参数可以指定泛型，任何需要指定数据类型的地方，都可以使用泛型来替代具体的数据类型，以此来表示此处可以使用比某种具体类型更为通用的数据类型。

而且，可以同时使用多个泛型，只要将不同的泛型定义为不同的名称即可。例如，HashMap类型是保存键值对的类型，它的key是一种泛型类型，它的值也是一种泛型类型。它的定义如下：

#![allow(unused)]
fn main() {
// 使用了三个泛型，分别是K、V、S，并且泛型S的默认类型是RandomState
struct HashMap<K, V, S = RandomState> {
  base: base::HashMap<K, V, S>,
}
}

实际上，Struct、Enum、impl、Trait等地方都可以使用泛型，仍然要注意的是，需要在类型的名称后或者impl后先声明泛型，才能使用已声明的泛型。

下面是一些简单的示例。

Struct使用泛型：

#![allow(unused)]
fn main() {
struct Container_tuple<T> (T)
struct Container_named<T: std::fmt::Display> {
  field: T,
}
}

例如，Vec类型就是泛型的Struct类型，其官方定义如下：

#![allow(unused)]
fn main() {
pub struct Vec<T> {
    buf: RawVec<T>,
    len: usize,
}
}

Enum使用泛型：

#![allow(unused)]
fn main() {
enum Option<T> {
  Some(T),
  None,
}
}

impl实现类型的方法时使用泛型：

#![allow(unused)]
fn main() {
struct Container<T>{
  item: T,
}

// impl后的T是声明泛型T
// Container<T>的T对应Struct类型Container<T>
impl<T> Container<T> {
  fn new(item: T) -> Self {
    Container {item}
  }
}
}

Trait使用泛型：

#![allow(unused)]
fn main() {
// 表示将某种类型T转换为当前类型
trait From<T> { 
  fn from(T) -> Self; 
}
}

某数据类型impl实现Trait时使用泛型：

#![allow(unused)]
fn main() {
use std::fmt::Debug;

trait Eatable {
  fn eat_me(&self);
}

#[derive(Debug)]
struct Food<T>(T);

impl<T: Debug> Eatable for Food<T> {
  fn eat_me(&self) {
    println!("Eating: {:?}", self);
  }
}
}

注意，上面impl时指定了T: Debug，它表示了Food<T>类型的T必须实现了Debug。为什么不直接在定义Struct时，将Food定义为struct Food<T: Debug>而是在impl Food时才限制泛型T呢？

通常，应当尽量不在定义类型时限制泛型的范围，除非确实有必要去限制。这是因为，泛型本就是为了描述更为抽象、更为通用的类型而存在的，限制泛型将使得类型变得更具体化，适用场景也更窄。但是在impl类型时，应当去限制泛型，并且遵守缺失什么功能就添加什么限制的规范，这样可以使得所定义的方法不会过度泛化，也不会过度具体化。

简单来说，尽量不去限制类型是什么，而是限制类型能做什么。

另一方面，即使定义struct Food<T: Debug>，在impl Food<T>时，也仍然要在impl时指定泛型的限制，否则将编译错误。

#![allow(unused)]
fn main() {
#[derive(Debug)]
struct Food<T: Debug>(T);
impl<T: Debug> Eatable for Food<T> {}
}

也就是说，如果某个泛型类型有对应的impl，那么在定义类型时指定的泛型限制很可能是多余的。但如果没有对应的impl，那么可能有必要在定义泛型类型时加上泛型限制。