Что такое мономорфизация в Rust и C++ и как она влияет на производительность?

Что такое мономорфизация простыми словами

Мономорфизация — это процесс, при котором компилятор превращает обобщённый (дженерик) код в конкретные версии для каждого типа, с которым этот код используется. Представьте, что у вас есть "рецепт" приготовления еды, где написано "возьмите любой фрукт". Мономорфизация — это когда вы для каждого фрукта (яблоко, банан, апельсин) создаёте отдельный рецепт: "как приготовить яблоко", "как приготовить банан" и т.д.

Как это работает в Rust

Когда вы пишете:

fn print_value<T: std::fmt::Display>(value: T) {
    println!("Value: {}", value);
}

fn main() {
    print_value(42);
    print_value("hello");
}

Компилятор Rust на этапе компиляции создаёт две отдельные функции:

// Мономорфизированная версия для i32
fn print_value_i32(value: i32) {
    println!("Value: {}", value);
}

// Мономорфизированная версия для &str
fn print_value_str(value: &str) {
    println!("Value: {}", value);
}

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

• Нет накладных расходов на виртуальные вызовы — компилятор знает точный тип на этапе компиляции
• Агрессивные оптимизации — компилятор может инлайнить, переставлять инструкции и даже полностью удалять код, если он не используется
• Специализация под тип — для целых чисел можно использовать арифметику, для строк — работу с памятью

Сравнение с C++

В C++ шаблоны работают абсолютно так же — это тоже мономорфизация. Когда вы пишете:

template <typename T>
void printValue(T value) {
    std::cout << "Value: " << value << std::endl;
}

int main() {
    printValue(42);
    printValue("hello");
    return 0;
}

Компилятор C++ создаст две отдельные функции: printValue<int> и printValue<const char*>. Разница лишь в том, что в Rust мономорфизация более контролируемая и безопасная (благодаря системе владения и типажам), а в C++ шаблоны могут генерировать огромное количество кода, если неаккуратно их использовать.

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

• Плюс: Максимальная производительность — нет виртуальных вызовов, всё решается на этапе компиляции
• Плюс: Оптимизация под конкретный тип — компилятор может применять специфичные для типа оптимизации
• Минус: Увеличение размера бинарника — каждая комбинация типов порождает отдельную копию кода
• Минус: Время компиляции — больше кода нужно скомпилировать и оптимизировать

Альтернатива: диспетчеризация через трейты (динамическая)

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

fn print_value_dyn(value: &dyn std::fmt::Display) {
    println!("Value: {}", value);
}

fn main() {
    print_value_dyn(&42);
    print_value_dyn(&"hello");
}

Здесь компилятор создаёт одну функцию, которая принимает указатель на трейт-объект. Вызов метода fmt происходит через виртуальную таблицу (vtable). Это уменьшает размер кода, но добавляет небольшой оверхед на каждый вызов (косвенный вызов через указатель).

Когда выбирать мономорфизацию: когда производительность критична и вы используете небольшое количество типов.

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

struct Container<T, U> {
    first: T,
    second: U,
}

impl<T: Clone, U: Clone> Container<T, U> {
    fn clone_both(&self) -> (T, U) {
        (self.first.clone(), self.second.clone())
    }
}

// Внутренняя реализация не зависит от типа
fn clone_inner(first: &dyn Clone, second: &dyn Clone) -> (Box<dyn Clone>, Box<dyn Clone>) {
    (first.clone(), second.clone())
}

// Обёртка с мономорфизацией только для вызова
impl<T: Clone + 'static, U: Clone + 'static> Container<T, U> {
    fn clone_both(&self) -> (T, U) {
        let (a, b) = clone_inner(&self.first, &self.second);
        (*a.downcast::<T>().unwrap(), *b.downcast::<U>().unwrap())
    }
}