测试实例：链表

enum 的一个常见用法就是创建链表（linked-list）：

  1. use List::*;
  3. enum List {
  4.     // Cons： 元组结构体，包含一个元素和一个指向下一节点的指针
  5.     Cons(u32, Box<List>),
  6.     // Nil： 末结点，表明链表结束
  7.     Nil,
  8. }
  10. // 方法可以在 enum 定义
  11. impl List {
  12.     // 创建一个空列表
  13.     fn new() -> List {
  14.         // `Nil` 为 `List` 类型
  15.         Nil
  16.     }
  18.     // 处理一个列表，得到一个头部带上一个新元素的同样类型的列表并返回此值
  19.     fn prepend(self, elem: u32) -> List {
  20.         // `Cons` 同样为 List 类型
  21.         Cons(elem, Box::new(self))
  22.     }
  24.     // 返回列表的长度
  25.     fn len(&self) -> u32 {
  26.         // `self` 必须匹配，因为这个方法的行为取决于 `self` 的变化类型
  27.         // `self` 为 `&List` 类型，`*self` 为 `List` 类型，一个具体的 `T` 类型的匹配
  28.         // 要参考引用 `&T` 的匹配
  29.         match *self {
  30.             // 不能得到 tail 的所有权，因为 `self` 是借用的；
  31.             // 而是得到一个 tail 引用
  32.             Cons(_, ref tail) => 1 + tail.len(),
  33.             // 基本情形：空列表的长度为 0
  34.             Nil => 0
  35.         }
  36.     }
  38.     // 将列表以字符串（堆分配的）的形式返回
  39.     fn stringify(&self) -> String {
  40.         match *self {
  41.             Cons(head, ref tail) => {
  42.                 // `format!` 和 `print!` 类似，但返回的是一个堆分配的字符串，而不是
  43.                 // 打印结果到控制台上
  44.                 format!("{}, {}", head, tail.stringify())
  45.             },
  46.             Nil => {
  47.                 format!("Nil")
  48.             },
  49.         }
  50.     }
  51. }
  53. fn main() {
  54.     // 创建一个空链表
  55.     let mut list = List::new();
  57.     // 追加一些元素
  58.     list = list.prepend(1);
  59.     list = list.prepend(2);
  60.     list = list.prepend(3);
  62.     // 显示链表的最后状态
  63.     println!("linked list has length: {}", list.len());
  64.     println!("{}", list.stringify());
  65. }

参见：

Box 和 方法