Дженерики в Rust: не бойся обобщений, пиши код как профи

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Дженерики в Rust: почему без них никуда?

Когда вы только начинаете писать на Rust, кажется, что система типов — это враг. Компилятор ругается на каждую запятую, а слово Generic вызывает дрожь в коленях. Но на самом деле дженерики (обобщённые типы) — это ваш лучший друг. Они позволяют писать гибкий, безопасный и переиспользуемый код без потери производительности.

В этой статье мы разберёмся, что такое generics в Rust, как их использовать в функциях, структурах и трейтах. Вы увидите, что обобщённое программирование — это не магия, а мощный инструмент, который делает ваш код чище и быстрее.

Что такое дженерики и зачем они нужны?

Представьте, что вы пишете функцию, которая находит максимальный элемент в массиве. Если бы не было дженериков, вам пришлось бы писать отдельную реализацию для i32, f64, String и так далее. Это долго, муторно и нарушает принцип DRY (Don't Repeat Yourself).

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

Синтаксис дженериков: от простого к сложному

1. Обобщённые функции

Начнём с базового примера. Допустим, мы хотим создать функцию, которая возвращает переданное значение (функция-идентичность):

fn identity<T>(value: T) -> T {
    value
}

fn main() {
    let n = identity(42);
    let s = identity("hello");
    println!("{}, {}", n, s); // 42, hello
}

Здесь <T> — это параметр типа. T может быть любым типом: числом, строкой, структурой. При вызове компилятор сам догадается, какой тип подставить. Работает это не за счёт динамической диспетчеризации (как в Java или Python), а за счёт генерации специализированного кода на этапе компиляции. Именно поэтому Rust не жертвует производительностью.

2. Ограничения типов (Trait Bounds)

Но что, если мы хотим не просто передать значение, а, например, сравнить два числа? Просто <T> не сработает, потому что не для всех типов определена операция сравнения. Нам нужно указать, что T должен реализовывать трейт PartialOrd:

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

fn main() {
    println!("{}", max(10, 20));        // 20
    println!("{}", max(3.14, 2.71));    // 3.14
}

Запись T: PartialOrd — это trait bound. Она говорит компилятору: «Используй только те типы, для которых определён порядок сравнения». Попробуйте передать в max две строки — и всё сработает, потому что String тоже реализует PartialOrd. А вот если передать структуру без реализации — получите ошибку компиляции.

3. Множественные ограничения

Иногда нужно, чтобы тип удовлетворял сразу нескольким трейтам. Например, чтобы он был и сравнимым, и клонируемым:

fn clone_and_max<T: PartialOrd + Clone>(a: T, b: T) -> T {
    let a_cloned = a.clone();
    let b_cloned = b.clone();
    if a_cloned > b_cloned { a } else { b }
}

Синтаксис T: PartialOrd + Clone означает, что тип должен реализовывать оба трейта. Это мощно, но не злоупотребляйте: слишком много ограничений усложняют читаемость.

Дженерики в структурах и перечислениях

Обобщённые структуры

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

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

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }

    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let int_point = Point::new(5, 10);
    let float_point = Point::new(1.5, 3.2);
    println!("x = {}", int_point.x()); // 5
}

Обратите внимание: impl<T> — это обязательная конструкция. Она говорит, что методы применяются ко всем Point<T>, независимо от типа. Если вы хотите написать метод только для конкретного типа (например, только для Point<f64>), вы пишете impl Point<f64>.

Несколько параметров типа

В одной структуре может быть несколько дженерик-параметров. Например, пара «ключ-значение»:

struct Pair<K, V> {
    key: K,
    value: V,
}

impl<K, V> Pair<K, V> {
    fn new(key: K, value: V) -> Self {
        Self { key, value }
    }
}

Типы K и V независимы: ключ может быть строкой, а значение — числом. Это основа для всех коллекций в стандартной библиотеке Rust (например, HashMap<K, V>).

Мономорфизация: почему Rust быстрый

Одна из главных фишек дженериков в Rust — мономорфизация. Это процесс, при котором компилятор для каждого используемого типа создаёт отдельную версию функции или структуры. Звучит страшно, но на деле это просто:

Вы пишете max(10, 20) — компилятор создаёт функцию max_i32.
Вы пишете max(3.14, 2.71) — создаётся max_f64.

На выходе вы получаете машинный код без всяких виртуальных таблиц и динамических проверок. Это даёт производительность, сравнимую с ручным написанием отдельных функций под каждый тип. Минус — размер бинарника может вырасти (так называемая «распухлость кода»), но современные линковщики с этим отлично справляются.