Rust 程序设计语言

高级类型

Rust 类型系统具有一些我们之前提到但尚未讨论的特性。我们将从讨论 newtype 开始，探讨为什么 newtype 作为类型很有用。然后，我们将继续讨论类型别名，这是一个与 newtype 类似但语义略有不同的特性。我们还将讨论 ! 类型和动态大小类型。

使用 Newtype 模式提高类型安全性和抽象性

注意：本节假设您已经阅读了前面的章节 “在外部类型上实现外部特征的 Newtype 模式”。

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

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

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

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

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 特征中的这些函数

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>；也就是说，一个 Result<T, E>，其中 E 填充为 std::io::Error。Write 特征函数签名最终看起来像这样

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 有一个特殊的类型叫做 !，在类型论中称为*空类型*，因为它没有值。我们更喜欢称之为*永不返回类型*，因为它在函数永不返回时充当返回值类型。以下是一个例子

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：一个分支以 continue 结尾的 match

当时，我们跳过了一些代码细节。在第 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 赋值。

永不返回类型在使用 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* 或*无大小类型*，它们允许我们使用大小只能在运行时确定的值的代码。

让我们深入研究一种名为 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 章“字符串切片”一节，切片数据结构只存储切片的起始位置和长度。因此，尽管 &T 是一个存储 T 所在内存地址的单个值，但 &str 是*两个*值：str 的地址及其长度。因此，我们可以在编译时知道 &str 值的大小：它是 usize 长度的两倍。也就是说，我们始终知道 &str 的大小，无论它引用的字符串有多长。总的来说，这就是 Rust 中使用动态大小类型的方式：它们有一些额外的元数据来存储动态信息的大小。动态大小类型的黄金法则是，我们必须始终将动态大小类型的值放在某种指针后面。

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

为了使用 DST，Rust 提供了 Sized trait 来确定类型的尺寸是否在编译时已知。对于大小在编译时已知的所有内容，都会自动实现此 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，所以我们需要在某种指针后面使用它。在这种情况下，我们选择了一个引用。

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