📚 第 13 章　实用工具特型

科学无非就是在自然界的多样性中寻求统一性（或者更确切地说，是在我们经验的多样性中寻求统一性）。用 Coleridge 的话说，诗歌、绘画、艺术，同样是在多样性中寻求统一性。 ——Jacob Bronowski

本章讲解了所谓的 Rust“实用工具”特型，这是标准库中各种特型的“百宝箱”，它们对 Rust 的编写方式有相当大的影响，所以，只有熟悉它们，你才能写出符合 Rust 语言惯例的代码并据此为你的 crate 设计公共接口，让用户认为这些接口是符合 Rust 风格的。 Rust 实用工具特型可分为三大类。 语言扩展特型 　　第 12 章中介绍的运算符重载特型能让你在自己的类型上使用 Rust 的表达式运算符，同样，还有其他几个标准库特型也是 Rust 的扩展点，允许你把自己的类型更紧密地集成进语言中。这类特型包括Drop、Deref 和 DerefMut，以及转换特型 From 和 Into。我们将在本章中讲解它们。 标记特型 　　这类特型多用作泛型类型变量的限界，以表达无法以其他方式捕获的约束条件。Sized 和 Copy 就属于这类特型。 公共词汇特型 　　这类特型不涉及任何编译器魔术，你完全可以在自己的代码中定义其等效特型。之所以定义它们，是为了给常见问题制定一些约定俗成的解决方案。这对 crate 和模块之间的公共接口来说特别有价值：通过减少不必要的变体，让接口更容易理解，也增加了把来自不同 crate 的特性轻易插接在一起的可能性，而且无须样板代码或自定义胶水代码。 这类特型包括 Default、引用借用特型 AsRef、AsMut、Borrow 与 BorrowMut、容错的转换特型 TryFrom 与 TryInto，以及ToOwned 特型（对 Clone 的泛化）。 表 13-1 对上述特型进行了汇总。 表 13-1：实用工具特型汇总表 特型 描述 Drop 析构器。每当丢弃一个值时，Rust 都要自动运行的清理代码 Sized 具有在编译期已知的固定大小类型的标记特型，与之相对的是动态大小类型（如切片） Clone 用来支持克隆值的类型 Copy 可以简单地通过对包含值的内存进行逐字节复制以进行克隆的类型的标记特型 Deref 与 DerefMut 智能指针类型的特型 Default 具有合理“默认值”的类型 AsRef 与 AsMut 用于从另一种类型中借入一种引用类型的转换特型

特型 描述 Borrow 与 BorrowMut 转换特型，类似 AsRef/AsMut，但能额外保证一致的哈希、排序和相等性 From 与 Into 用于将一种类型的值转换为另一种类型的转换特型 TryFrom 与 TryInto 用于将一种类型的值转换为另一种类型的转换特型，用于可能失败的转换 ToOwned 用于将引用转换为拥有型值的转换特型 还有另一些重要的标准库特型。第 15 章会介绍 Iterator 和 IntoIterator。第 16 章会介绍用于计算哈希值的 Hash 特型。 第 19 章会介绍两个用于标记线程安全类型的特型 Send 和 Sync。

13.1　Drop

当一个值的拥有者消失时，Rust 会丢弃（drop）该值。丢弃一个值就必须释放该值拥有的任何其他值、堆存储和系统资源。丢弃可能发生在多种情况下：当变量超出作用域时；在表达式语句的末尾；当截断一个向量时，会从其末尾移除元素；等等。 在大多数情况下，Rust 会自动处理丢弃值的工作。假设你定义了以下类型：

struct Appellation {
    name: String,
    nicknames: Vec<String>,
}

Appellation 拥有用作字符串内容和向量元素缓冲区的堆存储。每当 Appellation 被丢弃时，Rust 都会负责清理所有这些内容，无须你进行任何进一步的编码。但只要你想，也可以通过实现 std::ops::Drop 特型来自定义 Rust 该如何丢弃此类型的值：

trait Drop {
    fn drop(&mut self);
}

Drop 的实现类似于 C++ 中的析构函数或其他语言中的终结器。当一个值被丢弃时，如果它实现了 std::ops::Drop，那么 Rust 就会调用它的 drop 方法，然后像往常一样继续丢弃它的字段或元素拥有的任何值。这种对 drop 的隐式调用是调用该方法的唯一途径。如果你试图显式调用该方法，那么 Rust 会将其标记为错误。 Rust 在丢弃某个值的字段或元素之前会先对值本身调用 Drop::drop，该方法收到的值仍然是已完全初始化的。因此，在 Appellation 类型的 Drop 实现中可以随意使用其字段：

impl Drop for Appellation {
    fn drop(&mut self) {
        print!("Dropping {}", self.name);
        if !self.nicknames.is_empty() {
            print!(" (AKA {})", self.nicknames.join(", "));
        }
        println!("");
    }
}

基于该实现，可以编写以下内容：

{
    let mut a = Appellation {
        name: "Zeus".to_string(),
        nicknames: vec![
            "cloud collector".to_string(),
            "king of the gods".to_string(),
        ],
    };
    println!("before assignment");
    a = Appellation {
        name: "Hera".to_string(),
        nicknames: vec![],
    };
    println!("at end of block");
}

当我们将第二个 Appellation 赋值给 a 时，就会丢弃第一个 Appellation，而当我们离开 a 的作用域时，就会丢弃第二个 Appellation。上述代码会打印出以下内容：

before assignment 
Dropping Zeus (AKA cloud collector, king of the gods) at end of block Dropping Hera

Appellation 的 std::ops::Drop 实现只打印了一条消息，那么它的内存究竟是如何清理的呢？Vec 类型实现了 Drop，它会丢弃自己的每一个元素，然后释放它们占用的分配在堆上的缓冲区。 String 在内部使用 Vec 来保存它的文本，因此 String 不需要自己实现 Drop，它会让 Vec 负责释放这些字符。同样的原则 也适用于 Appellation 值：当一个值被丢弃时，最终由 Vec 的 Drop 实现来负责真正释放每个字符串的内容，并释放保存这些向量元素的缓冲区。至于 Appellation 值本身占用的内存，它的拥有者（可能是某个局部变量或某些数据结构）会负责释放。 如果一个变量的值移动到了别处，以致该变量在超出作用域时正处于未初始化状态，那么 Rust 将不会试图丢弃该变量，因为这里没有需要丢弃的值。 虽然根据控制流才能判断变量的值是否会移动出去，但这一原则仍然成立。在这种情况下，Rust 会使用一个不可见的标志来跟踪此变量的状态，该标志会指出是否需要丢弃此变量的值：

let p;
{
    let q = Appellation {
        name: "Cardamine hirsuta".to_string(),
        nicknames: vec!["shotweed".to_string(), "bittercress".to_string()],
    };
    if complicated_condition() {
        p = q;
    }
}
println!("Sproing! What was that?");

根据 complicated_condition 返回的是 true 还是 false，p 或 q 中的一个会最终拥有 Appellation，而另一个则会变成未初始化状态。这种差异决定了它是在 println! 之前还是之后丢弃 （因为 q 在 println! 之前就离开了作用域，而 p 则在 println! 之后离开的作用域）。虽然一个值可能会从一个地方移动到另一个地方，但 Rust 只会丢弃它一次。 除非正在定义某个拥有 Rust 不了解的资源类型，通常我们不需要自己实现 std::ops::Drop。例如，在 Unix 系统上，Rust 的标准库在内部使用了以下类型来表示操作系统的文件描述符：

struct FileDesc {
    fd: c_int,
}

FileDesc 的 fd 字段是当程序完成时应该关闭的文件描述符的编 号，c_int 是 i32 的别名。标准库为 FileDesc 实现的 Drop 如下所示：

impl Drop for FileDesc {
    fn drop(&mut self) {
        let _ = unsafe { libc::close(self.fd) };
    }
}

这里，libc::close 是 C 库中 close 函数的 Rust 名称。Rust 代码只能在 unsafe 块中调用 C 函数，因此在这里使用了一个 unsafe 块。 如果一个类型实现了 Drop，就不能再实现 Copy 特型了。如果类型是 Copy 类型，就表示简单的逐字节复制足以生成该值的独立副本。但是，对同一份数据多次调用同一个 drop 方法显然是错误的。 标准库预导入中包含一个丢弃值的函数 drop，但它的定义一点儿也不神奇：

fn drop<T>(_x: T) {}

换句话说，它会按值接受参数，从调用者那里获得所有权，然后什么也不做。当 _x 超出作用域时，Rust 自然会丢弃它的值，这跟对任何其他变量的操作一样。

13.2　Sized

固定大小类型是指其每个值在内存中都有相同大小的类型。Rust 中的几乎所有类型都是固定大小的，比如每个 u64 占用 8 字节，每个 (f32, f32, f32) 元组占用 12 字节。甚至枚举也是有大小的，也就是说，无论实际存在的是哪个变体，枚举总会占据足够的空间来容纳其最大的变体。尽管 Vec 拥有一个大小可变的堆分配缓冲区，但 Vec 值本身是指向“缓冲区、容量和长度”的指针，因此 Vec 也是一个固定大小类型。 所有固定大小类型都实现了 std::marker::Sized 特型，该特型没 有方法或关联类型。Rust 自动为所有适用的类型实现了 std::marker::Sized 特型，你不能自己实现它。Sized 的唯一用途是作为类型变量的限界：像 T: Sized 这样的限界要求 T 必须是在编译期已知的类型。由于 Rust 语言本身会使用这种类型的特型为具有某些特征的类型打上标记，因此我们将其称为标记特型。 然而，Rust 也有一些无固定大小类型，它们的值大小不尽相同。例 如，字符串切片类型 str（注意没有 &）就是无固定大小的。字符串字面量 “diminutive” 和 “big” 是对占用了 10 字节和 3 字节的 str 切片的引用，两者都展示在图 13-1 中。像 [T]（同样没有 &）这样的数组切片类型也是无固定大小的，即像 &[u8] 这样的共享引用可以指向任意大小的 [u8] 切片。因为 str 类型和 [T] 类型都表示不定大小的值集，所以它们是无固定大小类型。

图 13-1：对无固定大小的值的引用 Rust 中另一种常见的无固定大小类型是 dyn 类型，它是特型对象的引用目标。正如我们在 11.1.1 节中所解释的那样，特型对象是指向实现了给定特型的某个值的指针。例如，类型 &dyn std::io::Write 和 Box 是指向实现了 Write 特型的某个值的指针。引用目标可能是文件、网络套接字，或某种实现了 Write 的自定义类型。由于实现了 Write 的类型集是开放式的，因此 dyn Write 作为一个类型也是无固定大小的，也就是说它的值可以有各种大小。 Rust 不能将无固定大小的值存储在变量中或将它们作为参数传递。你只能通过像 &str 或 Box 这样的本身是固定大小的指针来处理它们。如图 13-1 所示，指向无固定大小值的指针始终是一个胖指针，宽度为两个机器字：指向切片的指针带有切片的长度，特型对象带有指向方法实现的虚表的指针。 特型对象和指向切片的指针在结构上很像。这两种类型都缺乏某种在使用它们时必要的信息。换句话说，你无法在不知道其长度的情况下对 [u8] 进行索引，也无法在不知道该对某个值使用 Write 的哪个 具体实现的情况下调用 Box 的方法。对于这两种类型，胖指针都会补齐类型中缺少的信息——它携带着长度或虚表指针。既然欠缺静态信息，那就用动态信息来弥补。由于无固定大小类型处处受限，因此大多数泛型类型变量应当被限制 为固定大小的 Sized 类型。事实上，鉴于这种情况的普遍性， Sized 已经成为 Rust 中的隐式默认值：如果你写 struct S { … }，那么 Rust 会将其理解为 struct S { … }。如果你不想以这种方式约束 T，就必须将其明确地排除，写成 struct S { … }。?Sized 语法专用于这种情况，意思是“不要求固定大小的”。如果你写 struct S { b: Box }，那么 Rust 将允许写成 S 和 S，这样这两个 Box 就变成了胖指针，而不像 S 和 S 的 Box 那样只是普通指针。 尽管存在一些限制，但无固定大小类型能让 Rust 的类型系统工作得更顺畅。阅读标准库文档时，你偶尔会遇到类型变量上的 ?Sized 限界，这几乎总是表明“给定的类型只能通过指针访问”，并能让其关联的代码与切片对象和特型对象以及普通值一起使用。当类型变量具有 ?Sized 限界时，人们认为它的大小不确定，既可能是固定大小，也可能不是。 除了切片对象和特型对象，还有另一种无固定大小类型。结构体类型的最后一个字段（而且只能是最后一个）可以是无固定大小的，并且这样的结构体本身也是无固定大小的。例如，Rc 引用计数指针的内部实现是指向私有类型 RcBox 的指针，后者把引用计数和 T 保存在一起。下面是 RcBox 的简化定义：

struct RcBox<T: ?Sized> {
    ref_count: usize,
    value: T,
}

Rc 是引用计数指针，其中的 value 字段是 Rc 对其进行引用计数的 T 类型。Rc 会解引用成指向 value 字段的指针。 ref_count 字段会保存其引用计数。 真正的 RcBox 只是标准库的一个实现细节，无法在外部使用。但假设我们正在使用前面这种定义，那么就可以将此 RcBox 与固定大小类型一起使用，比如 RcBox 的结果是一个固定大小的结构体类型。或者也可以将它与无固定大小类型一起使用，比如 RcBox（其中 Display 是可以通过 println! 之类的宏进行格式化的类型的特型），结果 RcBox 就成了无固定大小的结构体类型。 不能直接构建 RcBox 值，而应该先创建一个普通的固定大小的 RcBox，并让其 value 类型实现 Display，比如 RcBox。然后 Rust 就会允许你将引用 &RcBox 转换为胖引用 &RcBox：

let boxed_lunch: RcBox<String> = RcBox {
    ref_count: 1,
    value: "lunch".to_string(),
};
use std::fmt::Display;
let boxed_displayable: &RcBox<dyn Display> = &boxed_lunch;

在将值传给函数时会发生隐式转换，这样你就可以将 &RcBox 传给需要 &RcBox 的函数：

fn display(boxed: &RcBox<dyn Display>) {
    println!("For your enjoyment: {}", &boxed.value);
}
display(&boxed_lunch);

这将生成以下输出。

For your enjoyment: lunch

13.3 Clone

std::clone::Clone 特型适用于可复制自身的类型。Clone 定义如下：

trait Clone: Sized {
    fn clone(&self) -> Self;
    fn clone_from(&mut self, source: &Self) {
        *self = source.clone()
    }
}

clone 方法应该为 self 构造一个独立的副本并返回它。由于此方法的返回类型是 Self，并且函数本来也不可能返回无固定大小的值，因此 Clone 特型也是扩展自 Sized 特型的，进而导致其实现代码中的 Self 类型被限界成了 Sized。 克隆一个值通常还需要为它拥有的任何值分配副本，因此 clone 无 论在时间消耗还是内存占用方面都是相当昂贵的。例如，克隆 Vec 不仅会复制此向量，还会复制它的每个 String 元素。这就是 Rust 不会自动克隆值，而是要求你进行显式方法调用的原因。像 Rc 和 Arc 这样的引用计数指针类型属于例外，即克隆其中任何一个都只会增加引用计数并为你返回一个新指针。 clone_from 方法会把 self 修改成 source 的副本。 clone_from 的默认定义只是克隆 source，然后将其转移给 *self。这固然可行，但对于某些类型，有一种更快的方法可以获得同样的效果。假设 s 和 t 都是 String。s = t.clone(); 语句必然会克隆 t，丢弃 s 的旧值，然后将克隆后的值转移给 s，这会进行一次堆分配和一次堆释放。但是如果属于原始 s 的堆缓冲区有足够的容量来保存 t 的内容，则不需要分配或释放：可以简单地将 t 的文本复制到 s 的缓冲区并调整长度。在泛型代码中，应该优先使用 clone_from，以便充分利用这种优化。 如果你的 Clone 实现只需要简单地对类型中的每个字段或元素进行 clone，然后从这些克隆结果中构造一个新值，并且认为 clone_from 的默认定义已经足够好了，那么 Rust 也可以帮你实现：只要在类型定义上方写 #[derive(Clone)] 就可以了。 标准库中几乎所有能合理复制的类型都实现了 Clone。不仅 bool、 i32 等原始类型实现了 Clone，String、Vec 和 HashMap 等容器类型也实现了 Clone。而那些无法合理复制的类型（如 std::sync::Mutex）则没有实现 Clone。像 std::fs::File 这样的类型虽然可以复制，但如果操作系统无法提供必要的资源，则复制可能会失败。这些类型也没有实现 Clone，因为 clone 必须是不会失败的。作为替代，std::fs::File 提供了一个 try_clone 方法，该方法会返回一个 std::io::Result 值，用以报告失败信息。

13.4 Copy

在第 4 章中，我们曾解释说，对于大多数类型，赋值时会移动值，而不是复制它们。移动值可以更简单地跟踪它们所拥有的资源。但在 4.3 节中，我们指出了例外情况：不拥有任何资源的简单类型可以是 Copy 类型，对这些简单类型赋值会创建源的副本，而不会移动值并使源回到未初始化状态。 当时，我们没有充分解释 Copy 类型到底是什么，现在可以告诉你了：如果一个类型实现了 std::marker::Copy 标记特型，那么它就是 Copy 类型，其定义如下所示：

trait Copy: Clone {}

对于你自己的类型，这当然很容易实现：

impl Copy for MyType {}

但由于 Copy 是一种对语言有着特殊意义的标记特型，因此只有当类型需要一个浅层的逐字节复制时，Rust 才允许它实现 Copy。拥有任 何其他资源（比如堆缓冲区或操作系统句柄）的类型都无法实现 Copy。 任何实现了 Drop 特型的类型都不能是 Copy 类型。Rust 认为如果一个类型需要特殊的清理代码，那么就必然需要特殊的复制代码，因此不能是 Copy 类型。 与 Clone 一样，可以使用 #[derive(Copy)] 让 Rust 为你派生出 Copy 实现。你会经常看到同时使用 #[derive(Copy, Clone)] 进行派生的代码。 在允许一个类型成为 Copy 类型之前务必慎重考虑。尽管这样做能让该类型更易于使用，但也对其实现施加了严格的限制。如果复制的开销很高，那么就不适合进行隐式复制。4.3 节曾详细解释过这些因素。

13.5 Deref 与 DerefMut

通过实现 std::ops::Deref 特型和 std::ops::DerefMut 特型，可以指定像 * 和 . 这样的解引用运算符在你的类型上的行为。 像 Box 和 Rc 这样的指针类型就实现了这些特型，因此它 们可以像 Rust 的内置指针类型那样用。如果你有一个 Box 型的值 b，那么 *b 引用的就是 b 指向的 Complex（复数）值，而 b.re 引用的是它的实部。如果上下文对引用目标进行了赋值或借用了可变引用，那么 Rust 就会使用 DerefMut（解可变引用）特型，否则，只要通过 Deref 进行只读访问就够了。 这两个特型的定义如下所示：

trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}
trait DerefMut: Deref {
    fn deref_mut(&mut self) -> &mut Self::Target;
}

deref 方法会接受 &Self 引用并返回 &Self::Target 引用，而 deref_mut 方法会接受 &mut Self 引用并返回 &mut Self::Target 引用。Target 应该是 Self 包含、拥有或引用的资源：对于 Box，其 Target 类型是 Complex。请注意 DerefMut 扩展了 Deref：如果可以解引用并修改某些资源，那么当然也可以借入对它的共享引用。由于这些方法会返回与 &self 生命周期相同的引用，因此只要返回的引用还存在，self 就会一直处于已借出状态。 Deref 特型和 DerefMut 特型还扮演着另一个角色。由于 deref 会接受 &Self 引用并返回 &Self::Target 引用，因此 Rust 会利用这一点自动将前一种类型的引用转换为后一种类型的引用。换句话说，如果只要插入一个 deref 调用就能解决类型不匹配问题，那 Rust 就会插入它。实现 DerefMut 也可以为可变引用启用相应的转换。这些叫作隐式解引用：一种类型被“转换”成了另一种类型。 尽管隐式解引用也可以通过显式的方式写出来，但隐式解引用使用起来更方便。 如果你有一个 Rc 型的值 r，并想对其调用 String::find，就可以简单地写成 r.find(‘?’)，而不用写成 (*r).find(‘?’)：这种方法调用会隐式借入 r，并将 &Rc 转换为 &String，因为 Rc 实现了 Deref。 你可以对 String 值使用 split_at 之类的方法，虽然 split_at 是在 str 切片类型上定义的方法，但因为 String 实现了 Deref，所以可以这样写。String 不需要重新实现 str 的所有方法，因为可以将 &String 隐式转换为 &str。 如果你有一个字节向量 v 并且想将它传给需要字节切片 &[u8] 的函数，就可以简单地将 &v 作为参数传递，因为 Vec 实现了 Deref。 在必要的情况下，Rust 会连续应用多个隐式解引用。例如，使用前面提到的隐式转换，你可以将 split_at 直接应用于 Rc，因为 &Rc 解引用成了 &String，后者又解引用成了 &str，而 &str 具有 split_at 方法。 假设你有以下类型：

struct Selector<T> {
    /// 在这个`Selector`中可用的元素     elements: Vec<T>,

    /// `elements`中“当前”（current）元素的索引
    /// `Selector`的行为类似于指向当前元素的指针
    current: usize,
}

要让 Selector 的行为与文档型注释中声明的一致，就必须为该类 型实现 Deref 和 DerefMut：

use std::ops::{Deref, DerefMut};

impl<T> Deref for Selector<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.elements[self.current]
    }
}
impl<T> DerefMut for Selector<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.elements[self.current]
    }
}

给定上述实现，可以像下面这样使用 Selector：

let mut s = Selector {
    elements: vec!['x', 'y', 'z'],
    current: 2,
};

// 因为`Selector`实现了`Deref`，所以可以使用`*`运算符来引用它的当前元素 assert_eq!(*s, 'z');

// 通过隐式解引用直接在`Selector`上使用`char`的方法断言'z'是字母
assert!(s.is_alphabetic());

// 通过对此`Selector`的引用目标赋值，把'z'改成了'w'
*s = 'w';
assert_eq!(s.elements, ['x', 'y', 'w']);

Deref 特型和 DerefMut 特型旨在实现诸如 Box、Rc 和 Arc 之类的智能指针类型，以及其拥有型版本会频繁通过引用来使用的类型 （比如 Vec 和 String 就是 [T] 和 str 的拥有型版本）。仅仅为了让 Target 类型的方法能自动通过类型指针使用（就像 C++ 中那样让基类的方法在子类上可见）就为类型实现 Deref 和 DerefMut 是不对的。那样做的话并不总能如预期般工作，并且在出错时可能会让人困惑。隐式解引用有一个容易引起混淆的地方需要注意：Rust 会用它们来解决类型冲突，但并不会将其用于满足类型变量的限界。例如，下面的代码能正常工作：

let s = Selector {
    elements: vec!["good", "bad", "ugly"],
    current: 2,
};

fn show_it(thing: &str) {
    println!("{}", thing);
}
show_it(&s);

在调用 show_it(&s) 时，Rust 发现了一个类型为 &Selector<&str> 的实参（argument）和一个类型为 &str 的形参（parameter），据此找到了这个 Deref 实现，并根据需要将此调用重写成了 show_it(s.deref())。1

在需要做出区分的上下文中，本书选择将 argument 和 parameter 分别译为“实参”和 “形参”。除此之外，在表示一般性概念或不会导致混淆的情况下，二者均译为“参数”。 ——编者注但是，如果将 show_it 改成泛型函数，Rust 突然就报错了：

use std::fmt::Display;
fn show_it_generic<T: Display>(thing: T) {
    println!("{}", thing);
}
show_it_generic(&s);

Rust 报错说：

error: `Selector<&str>` doesn't implement `std::fmt::Display`    | 
31 |  show_it_generic(&s); 
   |                  ^^ 
   |                  | 
   |                  `Selector<&str>` cannot be formatted with 
   |                  the default formatter 
   |                  help: consider adding dereference here: 
`&*s`    | 
note: required by a bound in `show_it_generic`    | 
30 |  fn show_it_generic<T: Display>(thing: T) { println!("{}", 
thing); } 
   |                        ^^^^^^^ required by this bound    |                                in `show_it_generic`

这可能会令人困惑：为什么仅仅把函数改成泛型形式就会引入错误 呢？Selector<&str> 本身确实没有实现 Display，但它解引用成了 &str，而 &str 实现了 Display。 由于你要传入一个类型为 &Selector<&str> 的实参并且函数的形参类型为 &T，因此类型变量 T 必然是 Selector<&str>。然后， Rust 会检查这是否满足 T: Display 限界，但因为它不会通过隐式解引用来满足类型变量的限界，所以这个检查失败了。要解决此问题，可以使用 as 运算符进行显式转换：

show_it_generic(&s as &str);

或者，正如编译器建议的那样，可以使用 &* 进行强制转换。

show_it_generic(&*s);

13.6　Default

显然，某些类型具有合理的默认值：向量或字符串默认为空、数值默认为 0、Option 默认为 None，等等。这样的类型都可以实现 std::default::Default 特型：

trait Default {
    fn default() -> Self;
}

default 方法只会返回一个 Self 类型的新值。为 String 实现 Default 的代码一目了然：

impl Default for String {
    fn default() -> String {
        String::new()
    }
}

Rust 的所有集合类型（Vec、HashMap、BinaryHeap 等）都实现了 Default，其 default 方法会返回一个空集合。当你需要构建一些值的集合但又想让调用者来决定具体构建何种集合时，这很有 用。例如，Iterator 特型的 partition 方法会将迭代器生成的值分为两个集合，并使用闭包来决定每个值的去向：

use std::collections::HashSet;
let squares = [4, 9, 16, 25, 36, 49, 64];
let (powers_of_two, impure): (HashSet<i32>, HashSet<i32>) =
    squares.iter().partition(|&n| n & (n - 1) == 0);
assert_eq!(powers_of_two.len(), 3);
assert_eq!(impure.len(), 4);

闭包 |&n| n & (n-1) == 0 会使用一些位操作来识别哪些数值是 2 的幂，并且 partition 会使用它来生成两个 HashSet。不过， partition 显然不是专属于 HashSet 的，你可以用它来生成想要的任何种类的集合，只要该集合类型能够实现 Default 以生成一个初始的空集合，并且实现 Extend 以将 T 添加到集合中就可 以。String 实现了 Default 和 Extend，所以你可以这 样写：

let (upper, lower): (String, String) = "Great Teacher Onizuka"
    .chars()
    .partition(|&c| c.is_uppercase());
assert_eq!(upper, "GTO");
assert_eq!(lower, "reat eacher nizuka");

Default 的另一个常见用途是为表示大量参数集合的结构体生成默认值，其中大部分参数通常不用更改。例如，glium crate 为强大而复杂的 OpenGL 图形库提供了 Rust 绑定。glium:: DrawParameters 结构体包括 24 个字段，每个字段控制着 OpenGL 应该如何渲染某些图形的不同细节。glium draw 函数需要一个 DrawParameters 结构体作为参数。由于 DrawParameters 已经实现了 Default，因此只需提及想要更改的那些字段即可创建一个可以传给 draw 的结构体：

let params = glium::DrawParameters {     line_width: Some(0.02),     point_size: Some(0.02), 
    .. Default::default() 
};  
target.draw(..., &params).unwrap();

这会调用 Default::default() 来创建一个 DrawParameters 值，该值会使用其所有字段的默认值进行初始化，然后使用结构体的 .. 语法创建出一个更改了 line_width 字段和 point_size 字段的新值，最后就可以把它传给 target.draw 了。 如果类型 T 实现了 Default，那么标准库就会自动为 Rc、 Arc、Box、Cell、RefCell、Cow、 Mutex 和 RwLock 实现 Default。例如，类型 Rc 的默认值就是一个指向类型 T 的默认值的 Rc。如果一个元组类型的所有元素类型都实现了 Default，那么该元组类型也同样会实现 Default，这个元组的默认值包含每个元素的默认值。 Rust 不会为结构体类型隐式实现 Default，但是如果结构体的所有字段都实现了 Default，则可以使用 #[derive(Default)] 为此结构体自动实现 Default。

13.7　AsRef 与 AsMut

如果一个类型实现了 AsRef，那么就意味着你可以高效地从中借 入 &T。AsMut 是 AsRef 针对可变引用的对应类型。它们的定义如下所示：

trait AsRef<T: ?Sized> {
    fn as_ref(&self) -> &T;
}
trait AsMut<T: ?Sized> {
    fn as_mut(&mut self) -> &mut T;
}

例如，Vec 实现了 AsRef<[T]>，而 String 实现了 AsRef。还可以把 String 的内容借入为字节数组，因此 String 也实现了 AsRef<[u8]>。 AsRef 通常用于让函数更灵活地接受其参数类型。例如， std::fs::File::open 函数的声明如下：

fn open<P: AsRef<Path>>(path: P) -> Result<File>

open 真正想要的是 &Path，即代表文件系统路径的类型。有了这个函数签名，open 就能接受可以从中借入 &Path 的一切，也就是实现了 AsRef 的一切。这些类型包括 String 和 str、操作系统接口字符串类型 OsString 和 OsStr，当然还有 PathBuf 和 Path。有关完整列表，请参阅标准库的文档。这样你才能给 open 传入字符串字面量：

let dot_emacs = std::fs::File::open("/home/jimb/.emacs")?;

标准库的所有文件系统访问函数都会以这种方式接受路径参数。对调用者来说，其效果类似于 C++ 中的重载函数，只不过 Rust 采用的是另一种方式来确定可接受的参数类型。但这还不是全部。字符串字面量是 &str，实现了 AsRef 的 类型是 str，并没有 &。正如我们在 13.5 节中解释的那样，Rust 不会试图通过隐式解引用来满足类型变量限界，因此就算它们在这里也无济于事。 幸运的是，标准库包含了其通用实现：

impl<'a, T, U> AsRef< U> for &'a T
where
    T: AsRef< U>,
    T: ?Sized,
    U: ?Sized,
{
    fn as_ref(&self) -> &U {
        (*self).as_ref()
    }
}

换句话说，对于任意类型 T 和 U，只要满足 T: AsRef，就必然满足 &T: AsRef：只需追踪引用并像以前那样继续处理即可。特别是，如果满足 str: AsRef，那么也会满足 &str: AsRef。从某种意义上说，这是一种在检查类型变量的 AsRef 限界时获得受限隐式解引用的方法。 你可能会认为，如果一个类型实现了 AsRef，那么它也应该实现 AsMut。但是，这在某些情况下是不合适的。例如，我们已经提 到 String 实现了 AsRef<[u8]>，这是合理的，因为每个 String 肯定都有一个可以作为二进制数据访问的字节缓冲区。但是，String 要进一步保证这些字节是表示 Unicode 文本的一段格式良好的 UTF-8 编码，如果 String 实现了 AsMut<[u8]>，那么就会允许调用者将 String 的字节更改为他们想要的任何内容，这样你就不能再相信 String 一定是格式良好的 UTF-8 了。只有修改给定的 T 肯定不会违反此类型的不变性约束时，实现 AsMut 的类型才有意义。 尽管 AsRef 和 AsMut 非常简单，但为引用转换提供标准的泛型特型可避免更专用的转换特型数量激增。只要能实现 AsRef，就要尽量避免定义自己的 AsFoo 特型。

trait Borrow<Borrowed: ?Sized> {
    fn borrow(&self) -> &Borrowed;
}

impl<K, V> HashMap<K, V>
where
    K: Eq + Hash,
{
    fn get(&self, key: K) -> Option<&V> {}
}

impl<K, V> HashMap<K, V>
where
    K: Eq + Hash,
{
    fn get(&self, key: &K) -> Option<&V> {}
}

hashtable.get(&"twenty-two".to_string())

impl<K, V> HashMap<K, V>
where
    K: Eq + Hash,
{
    fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
    where
        K: Borrow<Q>,
        Q: Eq + Hash,
    {
    }
}

trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
    fn borrow_mut(&mut self) -> &mut Borrowed;
}

trait Into<T>: Sized {
    fn into(self) -> T;
}
trait From<T>: Sized {
    fn from(other: T) -> Self;
}

use std::net::Ipv4Addr;

fn ping< A>(address: A) -> std::io::Result<bool>
where
    A: Into<Ipv4Addr>,
{
    let ipv4_address = address.into();
}

println!("{:?}", ping(Ipv4Addr::new(23, 21, 68, 141))); // 传入一个 Ipv4Addr println!("{:?}", ping([66, 146, 219, 98]));             // 传入一个
[u8; 4] 
println!("{:?}", ping(0xd076eb94_u32));                 // 传入一个 u32

let addr1 = Ipv4Addr::from([66, 146, 219, 98]);
let addr2 = Ipv4Addr::from(0xd076eb94_u32);

let text = "Beautiful Soup".to_string();
let bytes: Vec<u8> = text.into();

type GenericError = Box<dyn std::error::Error + Send + Sync + 'static>;
type GenericResult<T> = Result<T, GenericError>;

fn parse_i32_bytes(b: &[u8]) -> GenericResult<i32> {
    Ok(std::str::from_utf8(b)?.parse::<i32>()?)
}

impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a> {
    fn from(err: E) -> Box<dyn Error + Send + Sync + 'a> {
        Box::new(err)
    }
}

let huge = 2_000_000_000_000i64;
let smaller = huge as i32;
println!("{}", smaller); // -1454759936

pub trait TryFrom<T>: Sized {
    type Error;
    fn try_from(value: T) -> Result<Self, Self::Error>;
}
pub trait TryInto<T>: Sized {
    type Error;
    fn try_into(self) -> Result<T, Self::Error>;
}

// 溢出时饱和，而非回绕
let smaller: i32 = huge.try_into().unwrap_or(i32::MAX);

let smaller: i32 =
    huge.try_into()
        .unwrap_or_else(|_| if huge >= 0 { i32::MAX } else { i32::MIN });

impl TryInto<LinearShift> for Transform {
    type Error = TransformError;

    fn try_into(self) -> Result<LinearShift, Self::Error> {
        if !self.normalized() {
            return Err(TransformError::NotNormalized);
        }
    }
}

trait ToOwned {
    type Owned: Borrow<Self>;
    fn to_owned(&self) -> Self::Owned;
}

enum Cow<'a, B: ?Sized>
where
    B: ToOwned,
{
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

use std::borrow::Cow;
use std::path::PathBuf;
fn describe(error: &Error) -> Cow<'static, str> {
    match *error {
        Error::OutOfMemory => "out of memory".into(),
        Error::StackOverflow => "stack overflow".into(),
        Error::MachineOnFire => "machine on fire".into(),
        Error::Unfathomable => "machine bewildered".into(),
        Error::FileNotFound(ref path) => format!("file not found: {}", path.display()).into(),
    }
}

println!("Disaster has struck: {}", describe(&error));

let mut log: Vec<String> = Vec::new();
log.push(describe(&error).into_owned());