В чем разница между трейтами в Rust и классами типов в Haskell?

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

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

1. Диспетчеризация: статическая vs динамическая

В Haskell классы типов всегда разрешаются во время компиляции — это статическая диспетчеризация. Компилятор знает конкретный тип и подставляет нужную реализацию метода. В Rust же есть оба варианта:

• Статическая диспетчеризация (мономорфизация) — через дженерики с ограничением по трейту:

  fn print_it<T: Show>(item: T) {
      item.show();
  }
  // Компилятор создаст отдельную версию для каждого типа

• Динамическая диспетчеризация — через трейт-объекты:

  fn print_dyn(item: &dyn Show) {
      item.show();
  }
  // Вызов через vtable, как в Java или C++

Это важно: в Rust вы выбираете между производительностью (статическая) и гибкостью (динамическая). В Haskell выбора нет — всегда статическая.

2. Условные реализации (где есть контексты)

В Haskell вы можете написать:

instance (Show a) => Show (Maybe a) where
    show Nothing = "Nothing"
    show (Just x) = "Just " ++ show x

В Rust это называется реализация с ограничениями (blanket implementations) и делается так:

impl<T: Show> Show for Option<T> {
    fn show(&self) -> String {
        match self {
            None => "None".to_string(),
            Some(x) => format!("Some({})", x.show()),
        }
    }
}

Однако есть важное ограничение: в Rust действует правило сиротских реализаций (orphan rule). Вы не можете реализовать чужой трейт для чужого типа в своем крейте. В Haskell таких ограничений нет — вы можете написать instance для любого типа в любом модуле.

3. Множественные параметры и функциональные зависимости

В Haskell можно определить класс с несколькими типами:

class Convert a b where
    convert :: a -> b

В Rust трейты всегда привязаны к одному типу (Self). Чтобы эмулировать многопараметрические классы, используют ассоциированные типы:

trait Convert {
    type Output;
    fn convert(&self) -> Self::Output;
}

impl Convert for i32 {
    type Output = f64;
    fn convert(&self) -> f64 {
        *self as f64
    }
}

Функциональные зависимости из Haskell (например, class Convert a b | a -> b) в Rust отсутствуют. Вместо этого Rust использует ассоциированные типы, которые гарантируют, что для одного Self будет только один Output.

4. Автоматическое наследование и deriving

В Haskell deriving работает для всех стандартных классов (Eq, Ord, Show, Read). В Rust #[derive()] работает только для трейтов, которые помечены как #[derive()] в стандартной библиотеке (Clone, Copy, Debug, PartialEq, Eq и т.д.). Для кастомных трейтов нужно писать макросы вручную.

5. Полиморфизм подтипов

В Rust трейты могут имитировать наследование через супертрейты:

trait Animal {
    fn make_sound(&self);
}

trait Dog: Animal {
    fn fetch(&self);
}

// Тип, реализующий Dog, обязан также реализовать Animal

В Haskell нет прямого аналога — вместо этого используют композицию классов или расширения с DefaultSignatures.

Итоговое сравнение

• Haskell: классы типов — это чисто статическая система, ориентированная на математическую абстракцию, с мощными возможностями (многопараметрические классы, функциональные зависимости, семейства типов).
• Rust: трейты — это прагматичный инструмент для организации кода, с поддержкой как статической, так и динамической диспетчеризации, но с более строгими правилами (orphan rule, отсутствие многопараметрических трейтов).

Если вы пришли из Haskell, вам не хватит функциональных зависимостей и свободы в определении инстансов. Но Rust компенсирует это низкоуровневым контролем и возможностью выбора между статической и динамической диспетчеризацией.

newtype ReverseInt = ReverseInt Int
instance Ord ReverseInt where
    compare (ReverseInt a) (ReverseInt b) = compare b a

trait Container {
    const MAX_SIZE: usize;
    type Item;
    fn add(&mut self, item: Self::Item);
}