Трейты в Rust: от первых шагов до понятного мономорфного кода

Введение: Зачем нужны трейты?

#

Допустим, в приложении для фитнеса есть разные упражнения: Pushups и Plank. Оба умеют считать потраченные калории, но делают это по-разному:

struct Pushups {
    reps: u32,
}

struct Plank {
    duration_sec: u32,
}

impl Pushups {
    fn calories_burned(&self) -> u32 {
        self.reps * 1
    }
}

impl Plank {
    fn calories_burned(&self) -> u32 {
        self.duration_sec * 2
    }
}

Теперь возникает задача — написать одну общую функцию подсчёта суммарных калорий для любого упражнения. Без абстракций нам пришлось бы дублировать код функции под каждый тип.

Как Rust решает эту проблему

#

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

Rust решает проблему с помощью Трейтов (Traits) — явных контрактов поведения.

Сначала объявляем контракт Workout:

pub trait Workout {
    fn calories_burned(&self) -> u32;
}

Затем заявляем, что наши структуры реализуют этот трейт:

impl Workout for Pushups {
    fn calories_burned(&self) -> u32 {
        self.reps * 1
    }
}

impl Workout for Plank {
    fn calories_burned(&self) -> u32 {
        self.duration_sec * 2
    }
}

Теперь мы можем написать одну единую функцию с ограничением (Trait Bound T: Workout):

fn total_calories<T: Workout>(exercises: &[T]) -> u32 {
    exercises.iter().map(|e| e.calories_burned()).sum()
}

Что происходит под капотом?

#

Компилятор не вызывает один универсальный метод для всех типов. Вместо этого он генерирует отдельную специализированную версию функции для каждого конкретного типа на этапе сборки (мономорфизация). В результате вы получаете удобство и абсолютную гибкость абстракций с производительностью чистого C (Zero-cost abstractions).

Попробуйте пошаговый интерактивный пример ниже: на первом шаге вы увидите ошибку компилятора при попытке вызвать метод у неотграниченного типа T, а на втором — её решение с помощью трейта Workout:

 1// ?compile_fail
 2struct Pushups {
 3    reps: u32,
 4}
 5
 6impl Pushups {
 7    fn calories_burned(&self) -> u32 {
 8        self.reps * 1
 9    }
10}
11
12// Попытка написать обобщенную функцию БЕЗ ограничения трейтом T
13fn total_calories<T>(exercises: &[T]) -> u32 {
14    exercises.iter().map(|e| e.calories_burned()).sum()
15}
16
17fn main() {
18    let pushups = vec![Pushups { reps: 20 }, Pushups { reps: 30 }];
19    let total = total_calories(&pushups);
20    println!("Всего калорий: {}", total);
21}
22

 1pub trait Workout {
 2    fn calories_burned(&self) -> u32;
 3}
 4
 5struct Pushups {
 6    reps: u32,
 7}
 8
 9struct Plank {
10    duration_sec: u32,
11}
12
13impl Workout for Pushups {
14    fn calories_burned(&self) -> u32 {
15        self.reps * 1
16    }
17}
18
19impl Workout for Plank {
20    fn calories_burned(&self) -> u32 {
21        self.duration_sec * 2
22    }
23}
24
25// Единая обобщенная функция с ограничением Trait Bound (T: Workout)
26fn total_calories<T: Workout>(exercises: &[T]) -> u32 {
27    exercises.iter().map(|e| e.calories_burned()).sum()
28}
29
30fn main() {
31    let pushups = vec![Pushups { reps: 20 }, Pushups { reps: 30 }];
32    let planks = vec![Plank { duration_sec: 60 }, Plank { duration_sec: 45 }];
33
34    println!("Калории от отжиманий: {}", total_calories(&pushups));
35    println!("Калории от планки: {}", total_calories(&planks));
36}
37

1. Что такое трейты и базовый синтаксис

#

Трейт (Trait) — это описание набора методов, которые должен уметь выполнять тип данных. Сам по себе трейт не хранит данные, он лишь декларирует поведение.

Давайте объявим простой трейт Say и реализуем его для структуры Dog. По соглашению Rust, имена трейтов и структур пишутся в CamelCase.

// Объявляем контракт: кто угодно может «сказать» что-то
pub trait Say {
    fn say(&self);
}

struct Dog;

// Реализуем контракт для нашей собаки
impl Say for Dog {
    fn say(&self) {
        println!("Woof!");
    }
}

Теперь, если у нас есть экземпляр Dog, мы можем вызвать этот метод через точку:

let dog = Dog;
dog.say(); // Выведет: Woof!

2. Анатомия элементов трейта

#

Внутри трейта могут находиться не только обычные методы экземпляра.

Методы и ассоциированные функции

#

• Методы экземпляра: принимают первым аргументом self, &self или &mut self. Вызываются через точку от объекта (dog.say()).
• Ассоциированные функции: не принимают self первым аргументом. Это своего рода «статические методы» типа, которые вызываются через двоеточие (Dog::species()).

pub trait Animal {
    fn name(&self) -> &str;        // Метод экземпляра
    fn species() -> &'static str; // Ассоциированная функция без self
}

struct Dog;

impl Animal for Dog {
    fn name(&self) -> &str { "Барбос" }
    fn species() -> &'static str { "Canis lupus" }
}

// Вызов ассоциированной функции:
println!("Вид: {}", Dog::species());

Реализации по умолчанию (Default Implementations)

#

Мы можем написать тело метода прямо в объявлении трейта. Тогда типы, реализующие его, могут просто использовать дефолтное поведение или переопределить его при необходимости:

pub trait Greet {
    fn hello(&self) {
        println!("Привет!"); // Реализация по умолчанию
    }
}

struct Student;
impl Greet for Student {} // Оставляем тело пустым — используется дефолтное поведение

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

#

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

pub trait HasId {
    const ID: usize;
}

struct User;
impl HasId for User {
    const ID: usize = 42;
}

3. Маркерные трейты: Copy и Clone

#

В Rust есть два фундаментальных трейта, которые управляют тем, как данные копируются в памяти:

let a = String::from("abc");
let b = a; // Move (владение перешло к b, 'a' больше недоступна)

let x = 5;
let y = x; // Copy (значение x неявно скопировано, обе переменные доступны)

Трейт Copy является наследником Clone (trait Copy: Clone {}). Вы не можете сделать тип Copy, не реализовав для него Clone.

• Числовые типы (i32, f64), bool, char реализуют Copy изначально.
• Для пользовательских структур мы можем автоматически вывести их с помощью макроса: #[derive(Copy, Clone)].

4. Дженерики, Trait Bounds и impl Trait

#

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

struct Point<T> {
    x: T,
    y: T,
}

Ограничения типажей (Trait Bounds)

#

Если мы хотим производить операции над обобщенным типом T, мы накладываем ограничения (Trait Bounds):

impl<T> Point<T>
where 
    T: std::ops::Add<Output=T> // Ограничиваем тип T контрактом сложения
{
    fn add(self, other: Self) -> Self {
        Self {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

Сокращенная форма impl Trait в аргументах функций

#

Для большинства обычных функций в Rust вместо явного fn foo<T: Trait>(x: T) используют более лаконичный синтаксис — impl Trait:

fn print_workout(w: impl Workout) {
    println!("Калории: {}", w.calories_burned());
}

Обе записи принципиально эквивалентны: компилятор точно так же превратит impl Trait в обобщенную функцию на этапе сборки.

5. Глубокий механизм мономорфизации

#

В отличие от языков вроде Java или C#, где дженерики стираются в рантайме, или Python, где всё проверяется на лету, Rust использует мономорфизацию.

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

// Исходный обобщенный код
fn foo<T>(x: T) { ... }

foo(5);       // Вызов с i32
foo("Hello"); // Вызов с &str

Под капотом компилятор концептуально превратит это в две обычные функции (конкретные имена в бинарнике будут другими — это лишь концептуальная иллюстрация):

fn foo_i32(x: i32) { ... }
fn foo_str(x: &str) { ... }

Плюсы мономорфизации:

#

• Нулевые издержки (Zero-cost abstraction): Программа работает максимально быстро, так как типы известны заранее, нет динамических проверок и лишней адресации в памяти.
• Агрессивный инлайнинг: Компилятор может легко встраивать код коротких функций прямо в место вызова.

Минусы мономорфизации:

#

• Замедление компиляции: Компилятору приходится собирать и оптимизировать кучу сгенерированных дубликатов функций.
• Раздувание бинарника (Code Bloat): Сгенерированный машинный код увеличивается в объеме.

Давайте посмотрим на работу трейтов и статического полиморфизма в действии в интерактивных слайдах ниже:

 1pub trait Say {
 2    fn say(&self) -> String;
 3}
 4
 5struct Dog;
 6
 7impl Say for Dog {
 8    fn say(&self) -> String {
 9        "Woof!".to_string()
10    }
11}
12
13fn main() {
14    let dog = Dog;
15    println!("Собака говорит: {}", dog.say());
16}
17

 1pub trait HasId {
 2    const ID: usize;
 3    type Err;
 4    fn from_str(s: &str) -> Result<Self, Self::Err> where Self: Sized;
 5}
 6
 7struct MyStruct;
 8
 9impl HasId for MyStruct {
10    const ID: usize = 10;
11    type Err = std::convert::Infallible;
12    fn from_str(_s: &str) -> Result<Self, Self::Err> {
13        Ok(MyStruct)
14    }
15}
16
17fn main() {
18    println!("ID структуры: {}", MyStruct::ID);
19    let _s = MyStruct::from_str("test").unwrap();
20}
21

 1// ?hidden:start
 2use std::fmt;
 3// ?hidden:end
 4
 5// Мы не можем реализовать Display для Vec<i32> напрямую, так как оба типа чужие.
 6// Но мы можем обернуть Vec в наш собственный кортежный тип (Newtype)!
 7struct MyVec(Vec<i32>);
 8
 9impl fmt::Display for MyVec {
10    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11        write!(f, "Мой вектор с {} элементами", self.0.len())
12    }
13}
14
15fn main() {
16    let my_vec = MyVec(vec![100, 200, 300]);
17    println!("{}", my_vec);
18}
19

 1// Трейт, который мы будем использовать как ограничение
 2trait Loud {
 3    fn loud_say(&self) -> String;
 4}
 5
 6// Обобщенная структура
 7struct Point<T> {
 8    x: T,
 9    y: T,
10}
11
12// Blanket implementation: реализуем Loud для любого Point<T>, если T реализует Loud
13impl<T: Loud> Loud for Point<T> {
14    fn loud_say(&self) -> String {
15        format!("X: {}, Y: {}", self.x.loud_say(), self.y.loud_say())
16    }
17}
18
19struct Dog;
20impl Loud for Dog {
21    fn loud_say(&self) -> String {
22        "WOOF!".to_string()
23    }
24}
25
26fn main() {
27    let p = Point { x: Dog, y: Dog };
28    println!("Точка кричит: {}", p.loud_say());
29}
30

 1// ?hidden:start
 2use std::mem::size_of;
 3// ?hidden:end
 4
 5trait A {
 6    fn get(&self) -> &str;
 7}
 8
 9trait B {
10    fn get(&self) -> &str;
11}
12
13struct S;
14
15impl A for S {
16    fn get(&self) -> &str { "реализация A" }
17}
18
19impl B for S {
20    fn get(&self) -> &str { "реализация B" }
21}
22
23fn main() {
24    let s = S;
25    // s.get(); // Ошибка компиляции: имя метода get неоднозначно!
26    
27    // Полный синтаксис (Fully Qualified Syntax) решает конфликт:
28    let from_a = <S as A>::get(&s);
29    let from_b = <S as B>::get(&s); 
30    
31    // Turbofish для явного указания типа функции:
32    let float_size = size_of::<f64>();
33    
34    println!("A: {}, B: {}, размер f64: {}", from_a, from_b, float_size);
35}
36

Проверь свои знания!

#

Пройдите короткий тест, чтобы закрепить понимание трейтов и статического полиморфизма в Rust.