Чем отличаются трейты в Rust от классов типов в Haskell?

Основные различия между трейтами Rust и классами типов Haskell

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

1. Сиротские реализации (orphan instances)

В Rust правило сирот (orphan rule) более мягкое: вы можете реализовать трейт для внешнего типа, если хотя бы один из них (трейт или тип) определён в вашем крейте. Например:

// Ваш крейт
use std::fmt::Display;

struct MyType;

// Можно: трейт Display из std, тип MyType из вашего крейта
impl Display for MyType {
    fn fmt(&self, f: &mut std::fmt::Formatter<_>) -> std::fmt::Result {
        write!(f, "MyType")
    }
}

В Haskell правило строже: вы не можете объявить instance для класса типов и типа, оба из которых определены в других модулях. Это сделано для предотвращения конфликтов (instance A для B может быть определён в модулях C и D, и компилятор не знает, какой выбрать).

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

Да, в Rust трейты могут содержать не только функции, но и типы и константы:

trait Container {
    type Item;           // ассоциированный тип
    const CAPACITY: usize; // ассоциированная константа
    
    fn get(&self, index: usize) -> Option<&Self::Item>;
    fn capacity(&self) -> usize {
        Self::CAPACITY
    }
}

impl Container for Vec<i32> {
    type Item = i32;
    const CAPACITY: usize = usize::MAX; // неограниченная ёмкость
    
    fn get(&self, index: usize) -> Option<&i32> {
        self.get(index)
    }
}

В Haskell ассоциированные типы появились только в расширении TypeFamilies, и это не является частью базового языка. Константы в классах типов отсутствуют.

3. Динамическая диспетчеризация (trait objects)

В Rust вы можете использовать трейты для динамической диспетчеризации через dyn Trait:

fn process(animals: Vec<Box<dyn Speak>>) {
    for animal in &animals {
        println!("{}", animal.speak());
    }
}

let dog = Dog;
let cat = Cat;
let animals: Vec<Box<dyn Speak>> = vec![Box::new(dog), Box::new(cat)];
process(animals);

В Haskell нет прямого аналога. Вместо этого используется экзистенциальная квантификация (расширение ExistentialQuantification):

{-# LANGUAGE ExistentialQuantification #-}
data SpeakBox = forall a. Speak a => SpeakBox a

process :: [SpeakBox] -> IO ()
process = mapM_ (\(SpeakBox a) -> makeSpeak a)

Но это не так естественно, как в Rust, и используется реже.

4. Ограничения на реализацию (coherence)

В Rust есть правило когерентности: для каждой пары (трейт, тип) может быть только одна реализация. Это предотвращает неоднозначности. В Haskell ситуация сложнее из-за возможности перекрывающихся экземпляров (overlapping instances), которые могут привести к неоднозначности.

5. Ассоциированные функции vs методы

В Rust трейты могут иметь методы (с &self) и ассоциированные функции (без self):

trait Math {
    fn add(a: i32, b: i32) -> i32; // ассоциированная функция
    fn square(&self) -> i32;       // метод
}

В Haskell все функции в классах типов принимают экземпляр типа как первый аргумент (или не принимают, если используется PhantomData).

Почему такие различия?

• Rust — системный язык, нацеленный на производительность и контроль памяти. Трейты — это способ абстракции с нулевой стоимостью, который должен работать эффективно как статически, так и динамически.
• Haskell — чисто функциональный язык с ленивыми вычислениями. Классы типов — это способ структурирования кода на уровне типов, и они тесно связаны с системой вывода типов.

Разные цели привели к разным компромиссам. Rust жертвует некоторой гибкостью (правило сирот) в пользу предсказуемости и производительности. Haskell жертвует простотой правил в пользу выразительности.

-- Haskell
foo :: Show a => a -> String

fn foo(animal: impl Speak) -> String {
    animal.speak()
}

class Container c where
    type Item c
    get :: c -> Int -> Maybe (Item c)

trait Container {
    type Item;
    fn get(&self, index: usize) -> Option<&Self::Item>;
}

let animals: Vec> = vec![Box::new(Dog), Box::new(Cat)];

struct Wrapper(Vec);
impl Display for Wrapper {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{:?}", self.0)
    }
}