Rust 编程 | 关联类型 | 提高可读性

简介

在本实验中，我们将探索 Rust 中关联类型的概念，它通过在 trait 中局部定义内部类型作为输出类型，提高了代码的可读性。这是通过在 trait 定义中使用 type 关键字来实现的。有了关联类型，使用该 trait 的函数不再需要显式地表达类型 A 和 B，从而使代码更加简洁和灵活。我们使用关联类型重写了上一节中的一个示例，以说明它们在实际中的用法。

注意：如果实验未指定文件名，你可以使用任何你想要的文件名。例如，你可以使用 main.rs，并通过 rustc main.rs &&./main 进行编译和运行。

关联类型

“关联类型”的使用通过将内部类型作为输出类型局部地移入 trait 中，提高了代码的整体可读性。trait 定义的语法如下：

// `A` 和 `B` 通过 `type` 关键字在 trait 中定义。
// （注意：这里的 `type` 与用于别名时的 `type` 不同）。
trait Contains {
    type A;
    type B;

    // 更新后的语法，用于泛型地引用这些新类型。
    fn contains(&self, _: &Self::A, _: &Self::B) -> bool;
}

请注意，使用 Contains trait 的函数不再需要显式地表达 A 或 B：

// 不使用关联类型
fn difference<A, B, C>(container: &C) -> i32 where
    C: Contains<A, B> {... }

// 使用关联类型
fn difference<C: Contains>(container: &C) -> i32 {... }

让我们使用关联类型重写上一节中的示例：

struct Container(i32, i32);

// 一个 trait，用于检查容器中是否存储了两个项。
// 还可以获取第一个或最后一个值。
trait Contains {
    // 在这里定义泛型类型，方法可以使用这些类型。
    type A;
    type B;

    fn contains(&self, _: &Self::A, _: &Self::B) -> bool;
    fn first(&self) -> i32;
    fn last(&self) -> i32;
}

impl Contains for Container {
    // 指定 `A` 和 `B` 是什么类型。如果 `input` 类型是 `Container(i32, i32)`，则 `output` 类型确定为 `i32` 和 `i32`。
    type A = i32;
    type B = i32;

    // `&Self::A` 和 `&Self::B` 在这里也是有效的。
    fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
        (&self.0 == number_1) && (&self.1 == number_2)
    }
    // 获取第一个数字。
    fn first(&self) -> i32 { self.0 }

    // 获取最后一个数字。
    fn last(&self) -> i32 { self.1 }
}

fn difference<C: Contains>(container: &C) -> i32 {
    container.last() - container.first()
}

fn main() {
    let number_1 = 3;
    let number_2 = 10;

    let container = Container(number_1, number_2);

    println!("容器中是否包含 {} 和 {}: {}",
        &number_1, &number_2,
        container.contains(&number_1, &number_2));
    println!("第一个数字：{}", container.first());
    println!("最后一个数字：{}", container.last());

    println!("差值是：{}", difference(&container));
}

探索 Rust 的关联类型

简介

关联类型

总结