Когда использовать ассоциированный тип, а когда обобщённый параметр в Rust?

Основное правило: ассоциированный тип — для одного фиксированного типа на реализацию, обобщённый — для множества вариантов

Ключевое различие между ассоциированными типами и обобщёнными параметрами в Rust заключается в следующем:

• Ассоциированный тип — это тип, который однозначно определяется реализацией трейта. Для каждой конкретной структуры, реализующей трейт, ассоциированный тип может быть только один.
• Обобщённый параметр — это тип, который выбирается пользователем при вызове. Одна и та же структура может реализовать трейт с разными обобщёнными параметрами.

Когда выбирать ассоциированный тип?

Ассоциированный тип идеально подходит, когда:

• Тип логически является частью самого трейта (например, тип элемента в итераторе, тип ошибки в парсере).
• Для одной реализации трейта этот тип должен быть фиксированным и не меняться от вызова к вызову.
• Вы хотите избежать лишних аннотаций типов у пользователя.

Рассмотрим ваш пример с итератором:

// Плохой вариант с обобщённым параметром
trait MyIterator<T> {
    fn next(&mut self) -> Option<T>;
}

struct MyVec<T> { data: Vec<T>, index: usize }

// Придётся реализовывать для каждого T отдельно?
impl<T> MyIterator<T> for MyVec<T> { ... }
// Теперь пользователь может написать:
let mut v = MyVec { data: vec![1,2,3], index: 0 };
let _: Option<String> = MyIterator::<String>::next(&mut v); // Ошибка компиляции? Нет, это разрешено, но бессмысленно!

С ассоциированным типом такой проблемы нет:

// Хороший вариант
trait MyIterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

impl<T> MyIterator for MyVec<T> {
    type Item = T; // Тип фиксирован для этой реализации
    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.data.len() {
            let item = self.data[self.index];
            self.index += 1;
            Some(item)
        } else {
            None
        }
    }
}
// Теперь MyVec<i32> может выдавать только i32, что логично

Когда выбирать обобщённый параметр?

Обобщённые параметры уместны, когда:

• Одна и та же структура должна реализовывать трейт с разными типами (например, контейнер, который можно параметризовать разными типами элементов).
• Тип влияет на поведение методов (например, трейт From<T> — вы можете преобразовать что угодно во что угодно).
• Вы хотите, чтобы пользователь мог выбирать тип при каждом вызове.

Пример с геометрическими фигурами

В вашем примере с фигурами ассоциированный тип — правильный выбор:

trait Shape {
    type Coord: num::Float; // Тип координат фиксирован для каждой фигуры
    fn area(&self) -> Self::Coord;
}

struct Circle<T> { radius: T }

impl<T: num::Float> Shape for Circle<T> {
    type Coord = T;
    fn area(&self) -> T {
        T::from(std::f64::consts::PI).unwrap() * self.radius * self.radius
    }
}

// Теперь Circle<f64> всегда использует f64 для координат
// Вы не сможете случайно вызвать area() и получить f32

Если бы вы использовали обобщённый параметр trait Shape<T>, то Circle<f64> мог бы реализовать Shape<f32> и Shape<f64> одновременно, что привело бы к путанице.

Практические рекомендации

• Используйте ассоциированный тип, если тип является неотъемлемой частью трейта и не должен меняться в рамках одной реализации.
• Используйте обобщённый параметр, если тип выбирается пользователем и может быть разным для одной и той же структуры.
• Помните, что ассоциированные типы упрощают использование трейтов в качестве типажей-ограничений (trait bounds).

В стандартной библиотеке Rust отличные примеры: Iterator использует ассоциированный тип Item, а From и Into — обобщённые параметры. Это не случайно: у итератора тип элемента фиксирован, а преобразование может быть любым.

// Реальный трейт Add использует ассоциированный тип
trait Add<Rhs = Self> {
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
}