Generics

Дженерик — параметр типа в сигнатуре функции или определении типа, ограниченный (опционально) trait bounds: fn largest<T: PartialOrd>(list: &[T]) -> &T работает для любого T, реализующего PartialOrd. Структуры тоже обобщаются: struct Pair<T> { x: T, y: T }. Компилятор не хранит "параметр типа" во время выполнения — вместо этого на этапе компиляции для каждого фактически использованного T генерируется отдельная конкретная версия кода.A generic is a type parameter in a function signature or type definition, optionally bounded by trait bounds: fn largest<T: PartialOrd>(list: &[T]) -> &T works for any T implementing PartialOrd. Structs are generic too: struct Pair<T> { x: T, y: T }. The compiler doesn't keep a "type parameter" around at runtime — instead, at compile time, a separate concrete version of the code is generated for each T actually used.

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest { largest = item; }
    }
    largest
}

// largest::<i32> и largest::<f64> — две независимые скомпилированные функции,// largest::<i32> and largest::<f64> — two independent compiled functions,
// без общего рантайм-пути и без единого параметра типа во время выполнения// with no shared runtime path and no type parameter at runtime at all
fn largest_i32(list: &[i32]) -> &i32 { /* ... *//* ... */ }
fn largest_f64(list: &[f64]) -> &f64 { /* ... *//* ... */ }

Мономорфизация архитектурно идентична шаблонам C++ — та же философия "нулевой цены абстракции", но с важным улучшением в проверке ограничений:Monomorphization is architecturally identical to C++ templates — the same "zero-cost abstraction" philosophy, but with an important improvement in bound checking:

Обобщённый метод может быть доступен только при дополнительных ограничениях сверх собственных границ структуры — это распространённый идиоматичный для Rust паттерн: структура обобщена по T без ограничений, но конкретный метод существует только когда T реализует нужные трейты.A generic method can be made available only under additional bounds beyond the struct's own — this is a common Rust-idiomatic pattern: the struct is generic over T with no bounds, but a specific method exists only when T implements the needed traits.

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

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self { Self { x, y } } // доступно для любого T// available for any T
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) { // доступен только когда T: Display + PartialOrd// only exists when T: Display + PartialOrd
        if self.x >= self.y {
            println!("largest is x = {}", self.x);
        } else {
            println!("largest is y = {}", self.y);
        }
    }
}

На этапе кодогенерации largest::<i32> и largest::<f64> становятся двумя независимыми скомпилированными функциями, не разделяющими ни единого рантайм-пути выполнения — компилятор буквально копирует и специализирует тело функции для каждого конкретного T.At codegen, largest::<i32> and largest::<f64> become two independent compiled functions sharing no runtime execution path whatsoever — the compiler literally copies and specializes the function body for each concrete T.

• The Rust Book — Generic Data Types
• Rust by Example — Generics