Как передать функцию в качестве параметра в Rust?

Основные подходы к передаче функций в Rust

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

1. Указатели на функции (Function pointers)

Самый простой способ — использовать тип fn(Args) -> Ret. Это работает для обычных функций, но не для замыканий, которые захватывают переменные:

fn apply_twice(f: fn(i32) -> i32, x: i32) -> i32 {
    f(f(x))
}

fn add_one(x: i32) -> i32 {
    x + 1
}

fn main() {
    let result = apply_twice(add_one, 5);
    println!("{}", result); // 7
}

2. Трейты Fn, FnMut, FnOnce (для замыканий)

Если вы хотите передавать не только обычные функции, но и замыкания, используйте обобщённые типы с трейтами:

• Fn — для функций, которые не изменяют захваченное окружение (можно вызывать несколько раз).
• FnMut — для функций, которые могут изменять захваченное окружение (можно вызывать несколько раз).
• FnOnce — для функций, которые можно вызвать только один раз (потребляют захваченные значения).

Пример с Fn:

fn apply_twice<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(f(x))
}

fn main() {
    let add_one = |x| x + 1;
    let result = apply_twice(add_one, 5);
    println!("{}", result); // 7

    // Замыкание, захватывающее переменную
    let offset = 10;
    let add_offset = |x| x + offset;
    let result2 = apply_twice(add_offset, 5);
    println!("{}", result2); // 25
}

3. Box<dyn Fn> (динамическая диспетчеризация)

Если тип функции неизвестен на этапе компиляции, можно использовать Box<dyn Fn>:

fn apply_twice_dyn(f: Box<dyn Fn(i32) -> i32>, x: i32) -> i32 {
    f(f(x))
}

fn main() {
    let closure = Box::new(|x| x * 2);
    let result = apply_twice_dyn(closure, 3);
    println!("{}", result); // 12
}

Когда что использовать?

• fn pointer — для простых функций без захвата окружения.
• Обобщённый Fn/FnMut/FnOnce — наиболее гибкий и производительный вариант (мономорфизация).
• Box<dyn Fn> — когда нужно хранить функции в коллекциях или передавать между потоками.

Важные нюансы

• Обычные функции автоматически реализуют Fn, FnMut и FnOnce.
• Замыкания без захвата окружения также можно преобразовать в fn pointer.
• Для изменения захваченных переменных используйте FnMut.
• Если замыкание потребляет захваченные значения (например, перемещает их), нужен FnOnce.

Теперь вы можете гибко передавать функции и замыкания в Rust!

trait Transformer {
    fn transform(&self, x: i32) -> i32;
}

struct AddOne;
impl Transformer for AddOne {
    fn transform(&self, x: i32) -> i32 {
        x + 1
    }
}

struct MultiplyBy(i32);
impl Transformer for MultiplyBy {
    fn transform(&self, x: i32) -> i32 {
        x * self.0
    }
}

fn apply_twice<T: Transformer>(t: &T, x: i32) -> i32 {
    t.transform(t.transform(x))
}

fn main() {
    let add = AddOne;
    let mul = MultiplyBy(2);
    println!("{}", apply_twice(&add, 5)); // 7
    println!("{}", apply_twice(&mul, 5)); // 20
}