枚举和模式匹配

枚举（enumerations），也被称作 enums。枚举允许你通过列举可能的成员（variants） 来定义一个类型

定义枚举

让我们看看一个需要诉诸于代码的场景，来考虑为何此时使用枚举更为合适且实用。假设我们要处理 IP 地址。
目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。

这是我们的程序可能会遇到的所有可能的 IP 地址类型：所以可以枚举出所有可能的值，这也正是此枚举名字的由来。

任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是

IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员
IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理适用于任何类型的 IP 地址的场景时应该把它们当作相同的类型

可以通过在代码中定义一个IpAddrKind枚举来表现这个概念并列出可能的 IP 地址类型，V4和V6。
这被称为枚举的成员（variants）：

enum IpAddrKind {
    V4,
    V6,
}

现在IpAddrKind就是一个可以在代码中使用的自定义数据类型了。

枚举值

可以像这样创建IpAddrKind两个不同成员的实例：

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

注意枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。
这么设计的益处是现在IpAddrKind::V4和IpAddrKind::V6都是IpAddrKind类型的。
例如，接着可以定义一个函数来获取任何IpAddrKind：

fn route(ip_type: IpAddrKind) { }

现在可以使用任一成员来调用这个函数：

route(IpAddrKind::V4);
route(IpAddrKind::V6);

使用枚举甚至还有更多优势。
进一步考虑一下我们的 IP 地址类型，目前没有一个存储实际 IP 地址 数据 的方法；只知道它是什么 类型 的

enum IpAddrKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

let home = IpAddr {
    kind: IpAddrKind::V4,
    address: String::from("127.0.0.1"),
};

let loopback = IpAddr {
    kind: IpAddrKind::V6,
    address: String::from("::1"),
};

这里我们定义了一个有两个字段的结构体IpAddr：IpAddrKind（之前定义的枚举）类型的kind字段和String类型address字段。

我们有这个结构体的两个实例。
第一个，home，它的kind的值是IpAddrKind::V4与之相关联的地址数据是127.0.0.1。
第二个实例，loopback，kind 的值是 IpAddrKind 的另一个成员，V6，关联的地址是::1。

我们使用了一个结构体来将kind和address打包在一起，现在枚举成员就与值相关联了。

我们可以使用一种更简洁的方式来表达相同的概念，仅仅使用枚举并将数据直接放进每一个枚举成员而不是将枚举作为结构体的一部分。
IpAddr枚举的新定义表明了V4和V6成员都关联了String值：

enum IpAddr {
    V4(String),
    V6(String),
}

let home = IpAddr::V4(String::from("127.0.0.1"));

let loopback = IpAddr::V6(String::from("::1"));

我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。

用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。
IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。
如果我们想要将V4地址存储为四个u8值而V6地址仍然表现为一个String，这就不能使用结构体了。
枚举则可以轻易处理的这个情况：

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);

let loopback = IpAddr::V6(String::from("::1"));

这些代码展示了使用枚举来存储两种不同 IP 地址的几种可能的选择。

让我们看看标准库是如何定义IpAddr的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的：

struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体。
甚至可以包含另一个枚举！另外，标准库中的类型通常并不比你设想出来的要复杂多少。

注意虽然标准库中包含一个IpAddr的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

这个枚举有四个含有不同类型的成员：

• Quit没有关联任何数据。
• Move包含一个匿名结构体。
• Write包含单独一个String。
• ChangeColor包含三个i32。

定义一个如上所示那样的有关联值的枚举的方式和定义多个不同类型的结构体的方式很相像，除了枚举不使用struct关键字以及其所有成员都被组合在一起位于Message类型下。
如下这些结构体可以包含与之前枚举成员中相同的数据:

struct QuitMessage; // 类单元结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

不过，如果我们使用不同的结构体，由于它们都有不同的类型，我们将不能像使用枚举那样轻易的定义一个能够处理这些不同类型的结构体的函数，因为枚举是单独一个类型。

结构体和枚举还有另一个相似点：就像可以使用impl来为结构体定义方法那样，也可以在枚举上定义方法。
这是一个定义于我们Message枚举上的叫做call的方法：

impl Message {
    fn call(&self) {
        // 在这里定义方法体
    }
}

let m = Message::Write(String::from("hello"));
m.call();

方法体使用了self来获取调用方法的值。
这个例子中，创建了一个值为Message::Write(String::from("hello"))的变量m，而且这就是当m.call()运行时call方法中的self的值。

让我们看看标准库中的另一个非常常见且实用的枚举Option。

使用use

enum Status {
    Rich,
    Poor,
}
enum Work {
    Civilian,
    Soldier,
}
fn main() {
    // 明确地 `use` 各个名称使他们直接可用而不需要手动加上作用域。
    use Status::{Poor, Rich};
    // 自动地 `use` `Work` 内部的各个名称。
    use Work::*;
    // 等价于 `Status::Poor`。
    let status = Poor;
    // 等价于 `Work::Civilian`。
    let work = Civilian;
    match status {
        // 注意这里少了作用域，因为上面显式地使用了 `use`。
        Rich => println!("The rich have lots of money!"),
        Poor => println!("The poor have no money..."),
    }
    match work {
        // 再次注意到这里没有作用域。
        Civilian => println!("Civilians work!"),
        Soldier  => println!("Soldiers fight!"),
    }
}
// The poor have no money...
// Civilians work!

C风格用法

// 拥有隐式辨别值（implicit discriminator）的 enum（从0开始计数）
enum Number {
    Zero,
    One,
    Two,
}
// 拥有显式辨别值（explicit discriminator）的 enum
enum Color {
    Red = 0xff0000,
    Green = 0x00ff00,
    Blue = 0x0000ff,
}
fn main() {
    // `enum` 可以转成整形。
    println!("zero is {}", Number::Zero as i32);
    println!("one is {}", Number::One as i32);
    println!("roses are #{:06x}", Color::Red as i32);
    println!("violets are #{:06x}", Color::Blue as i32);
}
// zero is 0
// one is 1
// roses are #ff0000

测试实例：链表

use List::*;
enum List {
    // Cons： 元组结构体，包含一个元素和一个指向下一节点的指针
    Cons(u32, Box<List>),
    // Nil： 末结点，表明链表结束
    Nil,
}
// 方法可以在 enum 定义
impl List {
    // 创建一个空列表
    fn new() -> List {
        // `Nil` 为 `List` 类型
        Nil
    }
    // 处理一个列表，得到一个头部带上一个新元素的同样类型的列表并返回此值
    fn prepend(self, elem: u32) -> List {
        // `Cons` 同样为 List 类型
        Cons(elem, Box::new(self))
    }
    // 返回列表的长度
    fn len(&self) -> u32 {
        // `self` 必须匹配，因为这个方法的行为取决于 `self` 的变化类型
        // `self` 为 `&List` 类型，`*self` 为 `List` 类型，一个具体的 `T` 类型的匹配
        // 要参考引用 `&T` 的匹配
        match *self {
            // 不能得到 tail 的所有权，因为 `self` 是借用的；
            // 而是得到一个 tail 引用
            Cons(_, ref tail) => 1 + tail.len(),
            // 基本情形：空列表的长度为 0
            Nil => 0
        }
    }
    // 将列表以字符串（堆分配的）的形式返回
    fn stringify(&self) -> String {
        match *self {
            Cons(head, ref tail) => {
                // `format!` 和 `print!` 类似，但返回的是一个堆分配的字符串，而不是
                // 打印结果到控制台上
                format!("{}, {}", head, tail.stringify())
            },
            Nil => {
                format!("Nil")
            },
        }
    }
}
fn main() {
    // 创建一个空链表
    let mut list = List::new();
    // 追加一些元素
    list = list.prepend(1);
    list = list.prepend(2);
    list = list.prepend(3);
    // 显示链表的最后状态
    println!("linked list has length: {}", list.len());
    println!("{}", list.stringify());
}
// linked list has length: 3
// 3, 2, 1, Nil

Option 枚举和其相对于空值的优势

在之前，我们看到了IpAddr枚举如何利用 Rust 的类型系统在程序中编码更多信息而不单单是数据。
接下来我们分析一个Option的案例，Option是标准库定义的另一个枚举。
Option类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值。
从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。

编程语言的设计经常要考虑包含哪些功能，但考虑排除哪些功能也很重要。
Rust 并没有很多其他语言中有的空值功能。空值（Null ）是一个值，它代表没有值。
在有空值的语言中，变量总是这两种状态之一：空值和非空值。

空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。
因为空和非空的属性无处不在，非常容易出现这类错误。

然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。

问题不在于概念而在于具体的实现。
为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。
这个枚举是Option<T>，而且它定义于标准库中，如下:

enum Option<T> {
    Some(T),
    None,
}

Option<T>枚举是如此有用以至于它甚至被包含在了 prelude 之中，你不需要将其显式引入作用域。
另外，它的成员也是如此，可以不需要Option::前缀来直接使用Some和None。
即便如此Option<T>也仍是常规的枚举，Some(T)和None仍是Option<T>的成员。

<T>语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数

目前，所有你需要知道的就是<T>意味着Option枚举的Some成员可以包含任意类型的数据。
这里是一些包含数字类型和字符串类型Option值的例子：

let some_number = Some(5);
let some_string = Some("a string");

let absent_number: Option<i32> = None;

如果使用None而不是Some，需要告诉 Rust Option<T>是什么类型的，因为编译器只通过None值无法推断出Some成员保存的值的类型。

当有一个Some值时，我们就知道存在一个值，而这个值保存在Some中。
当有个None值时，在某种意义上，它跟空值具有相同的意义：并没有一个有效的值。
那么，Option<T>为什么就比空值要好呢？

简而言之，因为Option<T>和T（这里T可以是任何类型）是不同的类型，编译器不允许像一个肯定有效的值那样使用Option<T>。
例如，这段代码不能编译，因为它尝试将Option<i8>与i8相加：

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

编译错误信息：

error[E0277]: cannot add `std::option::Option<i8>` to `i8`
 --> main.rs:7:17
  |
7 |     let sum = x + y;
  |                 ^ no implementation for `i8 + std::option::Option<i8>`
  |
  = help: the trait `std::ops::Add<std::option::Option<i8>>` is not implemented for `i8`

很好！事实上，错误信息意味着 Rust 不知道该如何将Option<i8>与i8相加，因为它们的类型不同。
当在 Rust 中拥有一个像i8这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需做空值检查。

只有当使用Option<i8>（或者任何用到的类型）的时候需要担心可能没有值，而编译器会确保我们在使用值之前处理了为空的情况。

换句话说，在对Option<T>进行T的运算之前必须将其转换为T。
通常这能帮助我们捕获到空值最常见的问题之一：假设某值不为空但实际上为空的情况。

不再担心会错误的假设一个非空值，会让你对代码更加有信心。
为了拥有一个可能为空的值，你必须要显式的将其放入对应类型的Option<T>中。
接着，当使用这个值时，必须明确的处理值为空的情况。只要一个值不是Option<T>类型，你就可以安全的认定它的值不为空。
这是 Rust 的一个经过深思熟虑的设计决策，来限制空值的泛滥以增加 Rust 代码的安全性。

Option 文档

熟悉Option<T>的方法将对你的 Rust 之旅非常有用。

match 控制流运算符

Rust 有一个叫做match的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码。
模式可由字面值、变量、通配符和许多其他内容构成；

match的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。

可以把match表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。
同样地，值也会通过match的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用。

因为刚刚提到了硬币，让我们用它们来作为一个使用match的例子！
我们可以编写一个函数来获取一个未知的（美帝）硬币，并以一种类似验钞机的方式，确定它是何种硬币并返回它的美分值

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

拆开value_in_cents函数中的match来看。
首先，我们列出match关键字后跟一个表达式，在这个例子中是coin的值。
这看起来非常像if使用的表达式，不过这里有一个非常大的区别：对于if，表达式必须返回一个布尔值，而这里它可以是任何类型的。

接下来是match的分支。一个分支有两个部分：一个模式和一些代码。
第一个分支的模式是值Coin::Penny而之后的=>运算符将模式和将要运行的代码分开。
这里的代码就仅仅是值1。每一个分支之间使用逗号分隔。

当match表达式执行时，它将结果值按顺序与每一个分支的模式相比较。
如果模式匹配了这个值，这个模式相关联的代码将被执行。
如果模式并不匹配这个值，将继续执行下一个分支，非常类似一个硬币分类器。可以拥有任意多的分支

每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个match表达式的返回值。

如果分支代码较短的话通常不使用大括号，如果想要在分支中运行多行代码，可以使用大括号。

例如，如下代码在每次使用Coin::Penny调用时都会打印出 “Lucky penny!”，同时仍然返回代码块最后的值，1：

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

绑定值的模式

匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值的。

作为一个例子，让我们修改枚举的一个成员来存放数据。1999 年到 2008 年间，美帝在 25 美分的硬币的一侧为 50 个州的每一个都印刷了不同的设计。其他的硬币都没有这种区分州的设计，所以只有这些 25 美分硬币有特殊的价值。可以将这些信息加入我们的enum，通过改变Quarter成员来包含一个State值

#[derive(Debug)] // 这样可以立刻看到州的名称
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

想象一下我们的一个朋友尝试收集所有 50 个州的 25 美分硬币。在根据硬币类型分类零钱的同时，也可以报告出每个 25 美分硬币所对应的州名称，这样如果我们的朋友没有的话，他可以将其加入收藏。

在这些代码的匹配表达式中，我们在匹配Coin::Quarter成员的分支的模式中增加了一个叫做state的变量。
当匹配到Coin::Quarter时，变量state将会绑定25美分硬币所对应州的值。接着在那个分支的代码中使用 state，如下：

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

如果调用value_in_cents(Coin::Quarter(UsState::Alaska))，coin将是Coin::Quarter(UsState::Alaska)。
当将值与每个分支相比较时，没有分支会匹配，直到遇到Coin::Quarter(state)。这时，state绑定的将会是值UsState::Alaska。
接着就可以在println!表达式中使用这个绑定了，像这样就可以获取Coin枚举的Quarter成员中内部的州的值。

// 创建一个 `enum` （枚举）来划分人的类别。注意命名和类型的信息是如何一起
// 明确规定变量的：
// `Engineer != Scientist` 和 `Height(i32) != Weight(i32)`。每者都不相同且
// 相互独立。
enum Person {
    // 一个 `enum` 可能是个 `unit-like`（类单元结构体），
    Engineer,
    Scientist,
    // 或像一个元组结构体，
    Height(i32),
    Weight(i32),
    // 或像一个普通的结构体。
    Info { name: String, height: i32 }
}
// 此函数将一个 `Person` enum 作为参数，无返回值。
fn inspect(p: Person) {
    // `enum` 的使用必须覆盖所有情形（无可辩驳的），所以使用 `match`
    // 以分支方式覆盖所有类型。
    match p {
        Person::Engineer    => println!("Is engineer!"),
        Person::Scientist       => println!("Is scientist!"),
        // 从 `enum` 内部解构 `i`
        Person::Height(i) => println!("Has a height of {}.", i),
        Person::Weight(i) => println!("Has a weight of {}.", i),
        // 将 `Info` 解构成 `name` 和 `height`。
        Person::Info { name, height } => {
            println!("{} is {} tall!", name, height);
        },
    }
}
fn main() {
    let person   = Person::Height(18);
    let amira    = Person::Weight(10);
    // `to_owned()` 从一个字符串 slice 创建一个具有所有权的 `String`。
    let dave     = Person::Info { name: "Dave".to_owned(), height: 72 };
    let rebecca  = Person::Scientist;
    let rohan    = Person::Engineer;
    inspect(person);
    inspect(amira);
    inspect(dave);
    inspect(rebecca);
    inspect(rohan);
}
// Has a height of 18.
// Has a weight of 10.
// Dave is 72 tall!
// Is scientist!
// Is engineer!

匹配 Option<T>

我们在之前的部分中使用Option<T>时，是为了从Some中取出其内部的T值；
我们还可以像处理Coin枚举那样使用match处理Option<T>！
与其直接比较硬币，我们将比较Option<T>的成员，不过match表达式的工作方式保持不变。

比如我们想要编写一个函数，它获取一个Option<i32>并且如果其中有一个值，将其加一。
如果其中没有值，函数应该返回None值并不尝试执行任何操作。

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);

匹配Some(T)

让我们更仔细地检查plus_one的第一行操作。
当调用plus_one(five)时，plus_one函数体中的x将会是值Some(5)。接着将其与每个分支比较。

None => None,

值Some(5)并不匹配模式None，所以继续进行下一个分支。

Some(i) => Some(i + 1),

Some(5)与Some(i)匹配吗？当然匹配！它们是相同的成员。
i绑定了Some中包含的值，所以i的值是5。接着匹配分支的代码被执行，所以我们将i的值加一并返回一个含有值6的新Some。

将match与枚举相结合在很多场景中都是有用的。
你会在 Rust 代码中看到很多这样的模式：match一个枚举，绑定其中的值到一个变量，接着根据其值执行代码。
这在一开始有点复杂，不过一旦习惯了，你会希望所有语言都拥有它！这一直是用户的最爱。

匹配是穷尽的

match还有另一方面需要讨论。考虑一下plus_one函数的这个版本，它有一个 bug 并不能编译：

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
    }
}

我们没有处理None的情况，所以这些代码会造成一个 bug。幸运的是，这是一个 Rust 知道如何处理的 bug

error[E0004]: non-exhaustive patterns: `None` not covered
 --> main.rs:2:11
  |
2 |     match x {
  |           ^ pattern `None` not covered
  |
  = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms

Rust 知道我们没有覆盖所有可能的情况甚至知道哪些模式被忘记了！
Rust 中的匹配是 穷尽的（exhaustive）：必须穷举到最后的可能性来使代码有效。
特别的在这个Option<T>的例子中，Rust 防止我们忘记明确的处理None的情况

_ 通配符

Rust 也提供了一个模式用于不想列举出所有可能值的场景。
例如，u8可以拥有 0 到 255 的有效的值，如果我们只关心 1、3、5 和 7 这几个值，就并不想必须列出 0、2、4、6、8、9 一直到 255 的值。
所幸我们不必这么做：可以使用特殊的模式_替代：

let some_u8_value = 0u8;
match some_u8_value {
    1 => println!("one"),
    3 => println!("three"),
    5 => println!("five"),
    7 => println!("seven"),
    _ => (),
}

_模式会匹配所有的值。通过将其放置于其他分支之后，_将会匹配所有之前没有指定的可能的值。()就是 unit 值，所以_的情况什么也不会发生。
因此，可以说我们想要对_通配符之前没有列出的所有可能的值不做任何处理。

然而，match在只关心 一个 情况的场景中可能就有点啰嗦了。为此 Rust 提供了if let。

if let 简单控制流

if let语法让我们以一种不那么冗长的方式结合if和let，来处理只匹配一个模式的值而忽略其他模式的情况。
考虑程序，它匹配一个Option<u8>值并只希望当值为3时执行代码：

fn main() {
    let some_u8_value = Some(0u8);
    match some_u8_value {
        Some(3) => println!("three"),
        _ => (),
    }
}

fn main() {
    let some_u8_value = Some(3u8);
    match some_u8_value {
        Some(3) => println!("three"),
        _ => (),
    }
}
// three

我们想要对Some(3)匹配进行操作但是不想处理任何其他Some<u8>值或None值。
为了满足match表达式（穷尽性）的要求，必须在处理完这唯一的成员后加上_ => ()，这样也要增加很多样板代码。

不过我们可以使用if let这种更短的方式编写。

fn main() {
    let some_u8_value = Some(3u8);
    if let Some(3) = some_u8_value {
        println!("three");
    }
}
// three

fn main() {
    let some_u8_value = Some(3u8);
    if Some(3) == some_u8_value {
        println!("three");
    }
}
// three

if let获取通过等号分隔的一个模式和一个表达式。
它的工作方式与match相同，这里的表达式对应match而模式则对应第一个分支。

使用if let意味着编写更少代码，更少的缩进和更少的样板代码。
然而，这样会失去match强制要求的穷尽性检查。match和if let之间的选择依赖特定的环境以及增加简洁度和失去穷尽性检查的权衡取舍。

换句话说，可以认为if let是match的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。

可以在if let中包含一个else。
else块中的代码与match表达式中的_分支块中的代码相同，这样的match表达式就等同于if let和else。
回忆一下Coin枚举的定义，其Quarter成员也包含一个UsState值。
如果想要计数所有不是 25 美分的硬币的同时也报告 25 美分硬币所属的州，可以使用这样一个match表达式：

let mut count = 0;
match coin {
    Coin::Quarter(state) => println!("State quarter from {:?}!", state),
    _ => count += 1,
}

或者可以使用这样的if let和else表达式：

let mut count = 0;
if let Coin::Quarter(state) = coin {
    println!("State quarter from {:?}!", state);
} else {
    count += 1;
}

如果你的程序遇到一个使用match表达起来过于啰嗦的逻辑，记住if let也在你的 Rust 工具箱中。

fn main() {
    let s = Some(String::from("123"));
    // let s = Some(String::from("233"));
    let s_t = String::from("123");
    match s {
        Some(val) if val == s_t => println!("hhhh"),
        _ => println!("..."),
    };
}

常量

// 在所有的作用域外声明全局变量。
static LANGUAGE: &'static str = "Rust";
const  THRESHOLD: i32 = 10;
fn is_big(n: i32) -> bool {
    // 在一般函数中访问常量
    n > THRESHOLD
}
fn main() {
    let n = 16;
    // 在 main 函数(主函数)中访问常量
    println!("This is {}", LANGUAGE);
    println!("The threshold is {}", THRESHOLD);
    println!("{} is {}", n, if is_big(n) { "big" } else { "small" });
    // 报错！不能修改一个 `const` 常量。
    // THRESHOLD = 5;
}
// This is Rust
// The threshold is 10
// 16 is big

总结

现在涉及到了如何使用枚举来创建有一系列可列举值的自定义类型。
也展示了标准库的Option<T>类型是如何帮助你利用类型系统来避免出错的。
当枚举值包含数据时，你可以根据需要处理多少情况来选择使用match或if let来获取并使用这些值。

你的 Rust 程序现在能够使用结构体和枚举在自己的作用域内表现其内容了。
在你的 API 中使用自定义类型保证了类型安全：编译器会确保你的函数只会得到它期望的类型的值。