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

Ключевое различие: количество реализаций на один тип

Вы совершенно правы в своём наблюдении. Основное различие между ассоциированными типами и обобщёнными параметрами заключается в том, сколько реализаций трейта может быть у одного конкретного типа.

Давайте разберём это на классическом примере — трейт Iterator из стандартной библиотеки Rust. У него есть ассоциированный тип Item:

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

Почему здесь используется ассоциированный тип, а не Iterator<T>? Представьте, что у вас есть структура Vec<i32>. Она может иметь только один "естественный" тип элемента при итерации — i32. Если бы трейт был обобщённым (Iterator<T>), то Vec<i32> мог бы реализовать Iterator<i32>, Iterator<&i32>, Iterator<String> и так далее. Это привело бы к путанице: какой именно итератор использовать? Ассоциированный тип жёстко фиксирует, что для данного типа существует ровно одна реализация итератора с одним типом элементов.

Когда использовать ассоциированные типы

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

• Тип однозначно определяется реализующим типом. Например, для трейта Add (сложение) результат всегда имеет тот же тип, что и операнды. Для трейта Deref целевой тип однозначно задаётся реализующим типом.
• Вы хотите гарантировать, что для типа будет только одна реализация. Это упрощает вывод типов и делает код более предсказуемым.
• Тип является "выходным" (output type). То есть он возвращается методами трейта, а не передаётся в них.

Пример: трейт для геометрических фигур:

trait Shape {
    type Area;  // Площадь может быть f64 или i32 — зависит от фигуры
    fn area(&self) -> Self::Area;
}

struct Circle { radius: f64 }
impl Shape for Circle {
    type Area = f64;
    fn area(&self) -> f64 { 3.14 * self.radius * self.radius }
}

struct Square { side: i32 }
impl Shape for Square {
    type Area = i32;
    fn area(&self) -> i32 { self.side * self.side }
}

Когда использовать обобщённые параметры

Используйте обобщённые параметры, когда:

• Тип является "входным" (input type). Например, трейт From<T> — вы конвертируете из какого-то типа, и для одного и того же типа-реализатора может быть много разных From-реализаций.
• Вы хотите иметь несколько реализаций для одного типа. Например, трейт PartialEq<Rhs> — вы можете сравнивать String с &str, String с String и т.д.
• Тип может варьироваться независимо от реализующего типа.

Пример: трейт для сравнения:

trait MyEqual<Rhs> {
    fn is_equal(&self, other: &Rhs) -> bool;
}

struct MyNumber(i32);
impl MyEqual<i32> for MyNumber {
    fn is_equal(&self, other: &i32) -> bool { self.0 == *other }
}
impl MyEqual<MyNumber> for MyNumber {
    fn is_equal(&self, other: &MyNumber) -> bool { self.0 == other.0 }
}

Практическое правило

Задайте себе вопрос: "Может ли у этого типа быть больше одной разумной реализации этого трейта?"

• Если нет (например, итератор для вектора всегда возвращает элементы вектора) — используйте ассоциированный тип.
• Если да (например, вы можете конвертировать i32 в String разными способами) — используйте обобщённый параметр.

Ассоциированные типы — это способ сказать: "Этот трейт определяет одну конкретную связь между типом и его свойством". Обобщённые параметры — это способ сказать: "Этот трейт может быть реализован для многих комбинаций типов".

// С ассоциированным типом — компилятор сам выводит
let item = some_iterator.next(); // знает, что Item = i32

// С обобщённым типом — может потребоваться аннотация
let item: i32 = some_iterator.next(); // если бы Iterator был обобщённым