Изучение ассоциированных типов в Rust

Введение

В этом лабораторном задании мы исследуем концепцию ассоциированных типов в Rust, которая позволяет повысить читаемость кода, определяя внутренние типы локально внутри трейта в качестве типов вывода. Это достигается с использованием ключевого слова type внутри определения трейта. С ассоциированными типами функции, использующие трейт, больше не нужно явно указывать типы A и B, что делает код более компактным и гибким. Мы переписываем пример из предыдущего раздела с использованием ассоциированных типов, чтобы показать их практическое применение.

Примечание: Если в лабораторном задании не указано имя файла, вы можете использовать любое имя файла, которое хотите. Например, вы можете использовать main.rs, скомпилировать и запустить его с помощью rustc main.rs &&./main.

Ассоциированные типы

Использование "ассоциированных типов" повышает общую читаемость кода, перемещая внутренние типы локально в трейт в качестве типов вывода. Синтаксис определения trait выглядит следующим образом:

// `A` и `B` определяются в трейте с использованием ключевого слова `type`.
// (Примечание: `type` в этом контексте отличается от `type`, когда оно используется для
// алиасов).
trait Contains {
    type A;
    type B;

    // Обновленный синтаксис для обращения к этим новым типам в общем виде.
    fn contains(&self, _: &Self::A, _: &Self::B) -> bool;
}

Обратите внимание, что функция, использующая trait Contains, больше не требует явного указания 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);

// Трейт, который проверяет, хранятся ли 2 элемента внутри контейнера.
// Также извлекает первое или последнее значение.
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));
}

Резюме

Поздравляем! Вы завершили лабораторную работу по ассоциированным типам. Вы можете практиковаться в других лабораторных работах в LabEx, чтобы улучшить свои навыки.