改进rust代码的35种具体方法-类型（七）-拥抱新型模式

上一篇文章

---

项目1描述了元组结构，其中struct的字段没有名称，而是用数字（self.0）引用。此项目侧重于具有单个条目的元组结构，这是一种在Rust中足够普遍的模式，它值得拥有自己的项目，并有自己的名称：newtype模式。

新类型模式的最简单用途是指示类型的额外语义，而不是其正常行为。为了说明这一点，想象一个将向Mars1发送卫星的项目。这是一个大项目，所以不同的小组构建了项目的不同部分。一个小组已经处理了火箭发动机的代码：

    /// Fire the thrusters. Returns generated force in Newton seconds.
    pub fn thruster_impulse(direction: Direction) -> f64 {
        // ...
        return 42.0;
    }

当不同的组处理惯性制导系统时：

    /// Update trajectory model for impulse, provided in pound force seconds.
    pub fn update_trajectory(force: f64) {
        // ...
    }

最终，这些不同的部分最终需要连接在一起：

        let thruster_force: f64 = thruster_impulse(direction);
        let new_direction = update_trajectory(thruster_force);

Rust包括一个类型别名功能，它允许不同的组更清楚地说明他们的意图：

    /// Units for force.
    pub type NewtonSeconds = f64;

    /// Fire the thrusters. Returns generated force.
    pub fn thruster_impulse(direction: Direction) -> NewtonSeconds {
        // ...
        return 42.0;
    }

    /// Units for force.
    pub type PoundForceSeconds = f64;

    /// Update trajectory model for impulse.
    pub fn update_trajectory(force: PoundForceSeconds) {
        // ...
    }

然而，类型别名实际上只是文档；它们是比之前版本的文档注释更强的提示，但没有什么能阻止在预期aPoundForceSeconds值的地方使用NewtonSeconds值：

        let thruster_force: NewtonSeconds = thruster_impulse(direction);
        let new_direction = update_trajectory(thruster_force);

Ruh-roh再一次。

这就是新类型模式有帮助的地方。

/// Units for force.
pub struct NewtonSeconds(pub f64);

/// Fire the thrusters. Returns generated force.
pub fn thruster_impulse(direction: Direction) -> NewtonSeconds {
    // ...
    return NewtonSeconds(42.0);
}

/// Units for force.
pub struct PoundForceSeconds(pub f64);

/// Update trajectory model for impulse.
pub fn update_trajectory(force: PoundForceSeconds) {
    // ...
}

顾名思义，新类型是新类型，因此编译器对象为类型转换（具体看 改进rust代码的35种具体方法-类型（六）-了解类型转换-CSDN博客）

    let thruster_force: NewtonSeconds = thruster_impulse(direction);
    let new_direction = update_trajectory(thruster_force);

error[E0308]: mismatched types
  --> newtype/src/main.rs:76:43
   |
76 |     let new_direction = update_trajectory(thruster_force);
   |                                           ^^^^^^^^^^^^^^ expected struct `PoundForceSeconds`, found struct `NewtonSeconds`

使用新类型为类型标记其他“单位”语义的相同模式也有助于减少布尔参数的模糊性。重温第一篇中的示例，使用新类型使参数的含义清晰：

struct DoubleSided(pub bool);

struct ColourOutput(pub bool);

fn print_page(sides: DoubleSided, colour: ColourOutput) {
    // ...
}

    print_page(DoubleSided(true), ColourOutput(false));

如果尺寸效率或二进制兼容性是一个问题，那么[repr(transparent)]属性确保新类型在内存中具有与内部类型相同的表示形式。

这是新类型的简单用法，这是第一篇的具体示例——将语义编码到类型系统中，以便编译器负责监管这些语义。

Bypassing the Orphan Rule for Traits（绕过孤儿规则的特质）

另一个需要新类型模式的常见但更微妙的场景围绕着Rust的孤儿规则。粗略地说，这说明您只能在以下情况下为类型实现特征：

• 你拥有这个特质，或者
• 你拥有这种类型。

试图为外部类型实现外部特征：

impl fmt::Display for rand::rngs::StdRng {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        write!(f, "<StdRng instance>")
    }
}

导致编译器错误（这反过来又指向了返回新类型的道路）。

error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
   --> newtype/src/main.rs:125:1
    |
125 | impl fmt::Display for rand::rngs::StdRng {
    | ^^^^^^^^^^^^^^^^^^^^^^------------------
    | |                     |
    | |                     `StdRng` is not defined in the current crate
    | impl doesn't use only types from inside the current crate
    |
    = note: define and implement a trait or new type instead

这种限制的原因是由于模棱两可的风险：如果独立图（项目25）中的两个不同的板条箱都（说）impl std::fmt::Display for rand::rngs::StdRng，那么编译器/链接器无法在它们之间进行选择。

这经常会导致挫折:例如，如果您试图序列化包含来自另一个crate的类型的数据，孤儿规则会阻止您为somerate::SomeType编写impl serde:: serialize。

但新类型模式意味着您正在创建一个您拥有的新类型，因此孤儿特征规则的第二部分适用。现在可以实现外国特质：

struct MyRng(rand::rngs::StdRng);

use std::fmt;
impl fmt::Display for MyRng {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        write!(f, "<Rng instance>")
    }
}

新型限制

新类型模式解决了这两类问题——防止单位转换和绕过孤儿规则——但它确实有一些尴尬：涉及新类型的每个操作都需要转发到内部类型。

在琐碎的层面上，这意味着代码必须始终使用thing.0，而不仅仅是thing，但这很容易，编译器会告诉你哪里需要它。

更显著的尴尬是，内部类型上的任何特征实现都丢失了：因为新类型是新类型，所以现有的内部实现不适用。

对于可派生特征，这只是意味着新类型声明最终会有很多derive：

    #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
    pub struct NewType(InnerType);

然而，对于更复杂的特征，需要一些转发样板来恢复内部类型的实现，例如：

    use std::fmt;
    impl fmt::Display for NewType {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
            self.0.fmt(f)
        }
    }

下一篇文章