Как указать, что поле структуры должно реализовывать трейт в Rust?

Использование обобщений (generics) для статической диспетчеризации

Самый производительный и часто рекомендуемый способ — использовать обобщённые типы с ограничением по трейту (trait bound). В этом случае конкретный тип поля определяется на этапе компиляции, и компилятор генерирует отдельную версию структуры для каждого используемого типа. Это называется статической диспетчеризацией (static dispatch) — вызов метода происходит напрямую, без поиска по таблице виртуальных функций.

trait Operation {
    fn compute(&self, a: i32, b: i32) -> i32;
}

struct AddOperation;
impl Operation for AddOperation {
    fn compute(&self, a: i32, b: i32) -> i32 { a + b }
}

struct SubtractOperation;
impl Operation for SubtractOperation {
    fn compute(&self, a: i32, b: i32) -> i32 { a - b }
}

// Структура с обобщённым полем
struct Calculator<T: Operation> {
    operation: T,
}

fn main() {
    let add_calc = Calculator { operation: AddOperation };
    let sub_calc = Calculator { operation: SubtractOperation };
    
    println!("Add: {}", add_calc.operation.compute(5, 3));   // 8
    println!("Sub: {}", sub_calc.operation.compute(5, 3));   // 2
}

Преимущества этого подхода:

• Максимальная производительность — нет накладных расходов на динамическую диспетчеризацию.
• Типобезопасность — компилятор проверяет, что поле реализует нужный трейт.
• Поддержка значений на стеке — не требуется выделение памяти в куче.

Недостаток: структура Calculator<AddOperation> и Calculator<SubtractOperation> — это разные типы. Вы не сможете хранить их в одном векторе или передавать в одну функцию без дополнительных ухищрений.

Использование трейт-объектов (Box<dyn Trait>)

Если вам нужна динамическая диспетчеризация (например, чтобы хранить разные реализации в одном контейнере), используйте трейт-объекты. Для этого тип должен быть «объектно-безопасным» (object-safe) — методы не должны возвращать Self по значению и не должны иметь обобщённых параметров.

trait Operation {
    fn compute(&self, a: i32, b: i32) -> i32;
}

struct Calculator {
    operation: Box<dyn Operation>, // Трейт-объект в куче
}

fn main() {
    let calc = Calculator {
        operation: Box::new(AddOperation),
    };
    println!("{}", calc.operation.compute(5, 3)); // 8
    
    // Можно менять реализацию во время выполнения
    let calc2 = Calculator {
        operation: Box::new(SubtractOperation),
    };
    println!("{}", calc2.operation.compute(5, 3)); // 2
}

Преимущества:

• Гибкость — можно хранить разные реализации в одном векторе Vec<Box<dyn Operation>>.
• Единый тип — все Calculator имеют одинаковый тип, независимо от поля.

Недостатки:

• Небольшие накладные расходы на динамическую диспетчеризацию (поиск метода через vtable).
• Выделение памяти в куче (Box).
• Трейт должен быть объектно-безопасным.

Какой подход выбрать?

Используйте обобщения, если:

• Конкретный тип известен на этапе компиляции.
• Вам важна максимальная производительность.
• Вы не планируете смешивать разные реализации в одной коллекции.

Используйте трейт-объекты, если:

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

enum OperationEnum {
    Add(AddOperation),
    Subtract(SubtractOperation),
}

impl OperationEnum {
    fn compute(&self, a: i32, b: i32) -> i32 {
        match self {
            OperationEnum::Add(op) => op.compute(a, b),
            OperationEnum::Subtract(op) => op.compute(a, b),
        }
    }
}

struct Calculator {
    operation: OperationEnum,
}

fn main() {
    let calc = Calculator {
        operation: OperationEnum::Add(AddOperation),
    };
    println!("{}", calc.operation.compute(5, 3)); // 8
}