关联类型

associated-types.md
commit ccb1d87d6faa9ff528d22b96595a0e2cbb16c0f2

关联类型是 Rust 类型系统中非常强大的一部分。它涉及到‘类型族’的概念，换句话说，就是把多种类型归于一类。这个描述可能比较抽象，所以让我们深入研究一个例子。如果你想编写一个Graph trait，你需要泛型化两个类型：点类型和边类型。所以你可能会像这样写一个 trait，Graph<N, E>：

  1. trait Graph<N, E> {
  2.     fn has_edge(&self, &N, &N) -> bool;
  3.     fn edges(&self, &N) -> Vec<E>;
  4.     // Etc.
  5. }

虽然这可以工作，不过显得很尴尬，例如，任何需要一个Graph作为参数的函数都需要泛型化的Node和Edge类型：

  1. fn distance<N, E, G: Graph<N, E>>(graph: &G, start: &N, end: &N) -> u32 { ... }

我们的距离计算并不需要Edge类型，所以函数签名中E只是写着玩的。

我们需要的是对于每一种Graph类型，都使用一个特定的的Node和Edge类型。我们可以用关联类型来做到这一点：

  1. trait Graph {
  2.     type N;
  3.     type E;
  5.     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  6.     fn edges(&self, &Self::N) -> Vec<Self::E>;
  7.     // Etc.
  8. }

现在，我们使用一个抽象的Graph了：

  1. fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> uint { ... }

这里不再需要处理Edge类型了。

让我们更详细的回顾一下。

定义关联类型

让我们构建一个Graphtrait。这里是定义：

  1. trait Graph {
  2.     type N;
  3.     type E;
  5.     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  6.     fn edges(&self, &Self::N) -> Vec<Self::E>;
  7. }

十分简单。关联类型使用type关键字，并出现在trait体和函数中。

这些type声明跟函数定义一样。例如，如果我们想N类型实现Display，这样我们就可以打印出点类型，我们可以这样写：

  1. use std::fmt;
  3. trait Graph {
  4.     type N: fmt::Display;
  5.     type E;
  7.     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  8.     fn edges(&self, &Self::N) -> Vec<Self::E>;
  9. }

实现关联类型

就像任何 trait，使用关联类型的 trait 用impl关键字来提供实现。下面是一个Graph的简单实现：

  1. # trait Graph {
  2. #     type N;
  3. #     type E;
  4. #     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  5. #     fn edges(&self, &Self::N) -> Vec<Self::E>;
  6. # }
  7. struct Node;
  9. struct Edge;
  11. struct MyGraph;
  13. impl Graph for MyGraph {
  14.     type N = Node;
  15.     type E = Edge;
  17.     fn has_edge(&self, n1: &Node, n2: &Node) -> bool {
  18.         true
  19.     }
  21.     fn edges(&self, n: &Node) -> Vec<Edge> {
  22.         Vec::new()
  23.     }
  24. }

这个可笑的实现总是返回true和一个空的Vec<Edge>，不过它提供了如何实现这类 trait 的思路。首先我们需要3个struct，一个代表图，一个代表点，还有一个代表边。如果使用别的类型更合理，也可以那样做，我们只是准备使用struct来代表这 3 个类型。

接下来是impl行，它就像其它任何 trait 的实现。

在这里，我们使用=来定义我们的关联类型。trait 使用的名字出现在=的左边，而我们impl的具体类型出现在右边。最后，我们在函数声明中使用具体类型。

trait 对象和关联类型

这里还有另外一个我们需要讨论的语法：trait对象。如果你试图从一个带有关联类型的 trait 创建一个 trait 对象，像这样：

  1. # trait Graph {
  2. #     type N;
  3. #     type E;
  4. #     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  5. #     fn edges(&self, &Self::N) -> Vec<Self::E>;
  6. # }
  7. # struct Node;
  8. # struct Edge;
  9. # struct MyGraph;
  10. # impl Graph for MyGraph {
  11. #     type N = Node;
  12. #     type E = Edge;
  13. #     fn has_edge(&self, n1: &Node, n2: &Node) -> bool {
  14. #         true
  15. #     }
  16. #     fn edges(&self, n: &Node) -> Vec<Edge> {
  17. #         Vec::new()
  18. #     }
  19. # }
  20. let graph = MyGraph;
  21. let obj = Box::new(graph) as Box<Graph>;

你会得到两个错误：

  1. error: the value of the associated type `E` (from the trait `main::Graph`) must
  2. be specified [E0191]
  3. let obj = Box::new(graph) as Box<Graph>;
  4.           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  5. 24:44 error: the value of the associated type `N` (from the trait
  6. `main::Graph`) must be specified [E0191]
  7. let obj = Box::new(graph) as Box<Graph>;
  8.           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~

我们不能这样创建一个trait对象，因为我们并不知道关联的类型。相反，我们可以这样写：

  1. # trait Graph {
  2. #     type N;
  3. #     type E;
  4. #     fn has_edge(&self, &Self::N, &Self::N) -> bool;
  5. #     fn edges(&self, &Self::N) -> Vec<Self::E>;
  6. # }
  7. # struct Node;
  8. # struct Edge;
  9. # struct MyGraph;
  10. # impl Graph for MyGraph {
  11. #     type N = Node;
  12. #     type E = Edge;
  13. #     fn has_edge(&self, n1: &Node, n2: &Node) -> bool {
  14. #         true
  15. #     }
  16. #     fn edges(&self, n: &Node) -> Vec<Edge> {
  17. #         Vec::new()
  18. #     }
  19. # }
  20. let graph = MyGraph;
  21. let obj = Box::new(graph) as Box<Graph<N=Node, E=Edge>>;

N=Node语法允许我们提供一个具体类型，Node，作为N类型参数。E=Edge也是一样。如果我们不提供这个限制，我们不能确定应该impl那个来匹配trait对象。