高级类型

Rust 的类型系统有一些我们到目前为止已经提到但尚未讨论的特性。我们将首先讨论 newtype 的一般概念，并研究为什么 newtype 作为类型是有用的。然后我们将继续讨论类型别名，这是一种类似于 newtype 但语义略有不同的特性。我们还将讨论 ! 类型和动态大小类型。

使用 Newtype 模式实现类型安全和抽象

注意：本节假设您已阅读之前的章节 “使用 Newtype 模式在外部类型上实现外部 Traits。”

newtype 模式对于超出我们目前讨论的任务也很有用，包括静态地强制值永远不会混淆以及指示值的单位。您在列表 19-15 中看到了使用 newtype 指示单位的示例：回想一下 Millimeters 和 Meters 结构体将 u32 值包装在 newtype 中。如果我们编写一个带有 Millimeters 类型参数的函数，我们将无法编译一个意外尝试使用 Meters 类型或普通 u32 类型的值调用该函数的程序。

我们还可以使用 newtype 模式来抽象化类型的某些实现细节：新类型可以公开一个与私有内部类型的 API 不同的公共 API。

Newtype 还可以隐藏内部实现。例如，我们可以提供一个 People 类型来包装一个 HashMap<i32, String>，该 HashMap 存储与人的姓名关联的 ID。使用 People 的代码将仅与我们提供的公共 API 交互，例如将姓名字符串添加到 People 集合的方法；该代码不需要知道我们在内部为姓名分配了一个 i32 ID。newtype 模式是实现封装以隐藏实现细节的一种轻量级方法，我们在 “隐藏实现细节的封装”第 18 章的章节中讨论过。

使用类型别名创建类型同义词

Rust 提供了声明类型别名的能力，为现有类型提供另一个名称。为此，我们使用 type 关键字。例如，我们可以像这样创建 i32 的别名 Kilometers

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

现在，别名 Kilometers 是 i32 的同义词；与我们在列表 19-15 中创建的 Millimeters 和 Meters 类型不同，Kilometers 不是一个单独的新类型。类型为 Kilometers 的值将被视为与 i32 类型的值相同

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

因为 Kilometers 和 i32 是相同的类型，所以我们可以添加这两种类型的值，并且可以将 Kilometers 值传递给接受 i32 参数的函数。但是，使用此方法，我们无法获得之前讨论的 newtype 模式带来的类型检查好处。换句话说，如果我们在某处混淆了 Kilometers 和 i32 值，编译器将不会给出错误。

类型同义词的主要用例是减少重复。例如，我们可能有像这样的冗长类型

Box<dyn Fn() + Send + 'static>

在函数签名和代码各处的类型注解中编写这种冗长类型可能会很麻烦且容易出错。想象一下，有一个项目充满了像列表 19-24 中那样的代码。

fn main() {
    let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));

    fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
        // --snip--
    }

    fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
        // --snip--
        Box::new(|| ())
    }
}

列表 19-24：在许多地方使用长类型

类型别名通过减少重复使此代码更易于管理。在列表 19-25 中，我们为冗长类型引入了一个名为 Thunk 的别名，并且可以用较短的别名 Thunk 替换该类型的所有用法。

fn main() {
    type Thunk = Box<dyn Fn() + Send + 'static>;

    let f: Thunk = Box::new(|| println!("hi"));

    fn takes_long_type(f: Thunk) {
        // --snip--
    }

    fn returns_long_type() -> Thunk {
        // --snip--
        Box::new(|| ())
    }
}

列表 19-25：引入类型别名 Thunk 以减少重复

这段代码更易于阅读和编写！为类型别名选择一个有意义的名称也可以帮助传达您的意图（thunk 是指稍后要评估的代码的词，因此它是存储的闭包的合适名称）。

类型别名也常用于 Result<T, E> 类型以减少重复。考虑标准库中的 std::io 模块。I/O 操作通常返回 Result<T, E> 以处理操作失败的情况。此库有一个 std::io::Error 结构体，表示所有可能的 I/O 错误。std::io 中的许多函数将返回 Result<T, E>，其中 E 是 std::io::Error，例如 Write trait 中的这些函数

use std::fmt;
use std::io::Error;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
    fn flush(&mut self) -> Result<(), Error>;

    fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}

Result<..., Error> 被重复了很多次。因此，std::io 具有此类型别名声明

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

由于此声明在 std::io 模块中，我们可以使用完全限定的别名 std::io::Result<T>；也就是说，E 填充为 std::io::Error 的 Result<T, E>。Write trait 函数签名最终看起来像这样

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

类型别名在两个方面有所帮助：它使代码更易于编写并且它为我们提供了跨 std::io 的一致接口。因为它是一个别名，所以它只是另一个 Result<T, E>，这意味着我们可以使用任何适用于 Result<T, E> 的方法，以及像 ? 运算符这样的特殊语法。

永不返回的 Never 类型

Rust 有一个名为 ! 的特殊类型，在类型理论术语中称为空类型，因为它没有值。我们更喜欢称其为 never 类型，因为它在函数永远不会返回时充当返回类型的位置。这是一个例子

fn bar() -> ! {
    // --snip--
    panic!();
}

这段代码被解读为“函数 bar 永不返回。” 永不返回的函数称为发散函数。我们无法创建 ! 类型的值，因此 bar 永远不可能返回。

但是，永远无法为其创建值的类型有什么用呢？回想一下列表 2-5 中的代码，猜数字游戏的一部分；我们在列表 19-26 中重现了一部分。

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

列表 19-26：一个 match，其一个分支以 continue 结尾

当时，我们跳过了此代码中的一些细节。在第 6 章的 “match 控制流运算符”节中，我们讨论了 match 分支必须都返回相同的类型。因此，例如，以下代码不起作用

fn main() {
    let guess = "3";
    let guess = match guess.trim().parse() {
        Ok(_) => 5,
        Err(_) => "hello",
    };
}

此代码中 guess 的类型必须是整数和字符串，而 Rust 要求 guess 只有一个类型。那么 continue 返回什么呢？我们如何在列表 19-26 中允许从一个分支返回 u32，而另一个分支以 continue 结尾？

您可能已经猜到，continue 表达式的类型为 !。也就是说，当 Rust 计算 guess 的类型时，它会查看两个 match 分支，前者具有 u32 值，后者具有 ! 值。因为 ! 永远不能有值，所以 Rust 决定 guess 的类型为 u32。

描述此行为的正式方法是，! 类型的表达式可以被强制转换为任何其他类型。我们被允许用 continue 结束这个 match 分支，因为 continue 不返回一个值；相反，它将控制权移回循环的顶部，因此在 Err 的情况下，我们永远不会为 guess 赋值。

never 类型也适用于 panic! 宏。回想一下我们在 Option<T> 值上调用的 unwrap 函数，以生成值或 panic，定义如下

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

use crate::Option::*;

impl<T> Option<T> {
    pub fn unwrap(self) -> T {
        match self {
            Some(val) => val,
            None => panic!("called `Option::unwrap()` on a `None` value"),
        }
    }
}

在此代码中，发生的情况与列表 19-26 中的 match 相同：Rust 看到 val 的类型为 T，而 panic! 的类型为 !，因此整个 match 表达式的结果是 T。此代码有效，因为 panic! 不生成值；它结束程序。在 None 的情况下，我们不会从 unwrap 返回值，因此此代码是有效的。

具有 ! 类型的最后一个表达式是 loop

fn main() {
    print!("forever ");

    loop {
        print!("and ever ");
    }
}

在这里，循环永远不会结束，所以 ! 是表达式的类型。但是，如果我们包含 break，情况就不是这样了，因为循环会在到达 break 时终止。

动态大小类型和 Sized Trait

Rust 需要了解其类型的某些细节，例如为特定类型的值分配多少空间。这使得其类型系统的一个角落起初有点令人困惑：动态大小类型的概念。这些类型有时被称为 DST 或unsized 类型，它们允许我们编写使用仅在运行时才能知道大小的值的代码。

让我们深入研究一个名为 str 的动态大小类型的细节，我们在本书中一直在使用它。没错，不是 &str，而是 str 本身，它是一个 DST。在运行时之前我们无法知道字符串有多长，这意味着我们无法创建 str 类型的变量，也无法接受 str 类型的参数。考虑以下不起作用的代码

fn main() {
    let s1: str = "Hello there!";
    let s2: str = "How's it going?";
}

Rust 需要知道为特定类型的任何值分配多少内存，并且一种类型的所有值都必须使用相同数量的内存。如果 Rust 允许我们编写此代码，则这两个 str 值将需要占用相同数量的空间。但是它们具有不同的长度：s1 需要 12 字节的存储空间，而 s2 需要 15 字节。这就是为什么不可能创建保存动态大小类型的变量的原因。

那么我们该怎么办呢？在这种情况下，您已经知道答案：我们将 s1 和 s2 的类型设为 &str 而不是 str。回想一下第 4 章的 “字符串 Slice”节，slice 数据结构仅存储 slice 的起始位置和长度。因此，尽管 &T 是一个存储 T 所在内存地址的单个值，但 &str 是两个值：str 的地址及其长度。因此，我们可以在编译时知道 &str 值的大小：它是 usize 长度的两倍。也就是说，我们始终知道 &str 的大小，无论它引用的字符串有多长。通常，这是在 Rust 中使用动态大小类型的方式：它们具有额外的元数据位，用于存储动态信息的大小。动态大小类型的黄金法则是，我们必须始终将动态大小类型的值放在某种指针之后。

我们可以将 str 与各种指针组合使用：例如，Box<str> 或 Rc<str>。实际上，您以前见过这种情况，但使用的是不同的动态大小类型：trait。每个 trait 都是一个动态大小类型，我们可以通过使用 trait 的名称来引用它。在第 18 章的 “使用 Trait Objects 来允许不同类型的值”节中，我们提到要将 trait 用作 trait object，我们必须将它们放在指针之后，例如 &dyn Trait 或 Box<dyn Trait> (Rc<dyn Trait> 也可以)。

为了使用 DST，Rust 提供了 Sized trait 来确定类型的size是否在编译时已知。此 trait 会自动为所有大小在编译时已知的事物实现。此外，Rust 隐式地向每个泛型函数添加了 Sized 约束。也就是说，像这样的泛型函数定义

fn generic<T>(t: T) {
    // --snip--
}

实际上被视为我们编写了这样的代码

fn generic<T: Sized>(t: T) {
    // --snip--
}

默认情况下，泛型函数仅适用于在编译时已知大小的类型。但是，您可以使用以下特殊语法来放宽此限制

fn generic<T: ?Sized>(t: &T) {
    // --snip--
}

?Sized 上的 trait 约束意味着 “T 可能是或可能不是 Sized”，并且此表示法覆盖了泛型类型必须在编译时具有已知大小的默认设置。具有此含义的 ?Trait 语法仅适用于 Sized，而不适用于任何其他 trait。

另请注意，我们将 t 参数的类型从 T 切换到 &T。因为类型可能不是 Sized，所以我们需要在某种指针之后使用它。在这种情况下，我们选择了引用。

接下来，我们将讨论函数和闭包！