¿Cómo se pasa una función Rust como parámetro?

¿Puedo pasar una función como parámetro? Si no es así, ¿cuál es una buena alternativa?

Probé algunas sintaxis diferentes pero no encontré la correcta. Sé que puedo hacerlo:

fn example() {
    let fun: fn(value: i32) -> i32;
    fun = fun_test;
    fun(5i32);
}

fn fun_test(value: i32) -> i32 {
    println!("{}", value);
    value
}

pero eso no pasa la función como parámetro a otra función:

fn fun_test(value: i32, (some_function_prototype)) -> i32 {
    println!("{}", value);
    value
}

Seguro que puede:

fn fun_test(value: i32, f: &dyn Fn(i32) -> i32) -> i32 {
    println!("{}", f(value));
    value
}

fn times2(value: i32) -> i32 {
    2 * value
}

fn main() {
    fun_test(5, &times2);
}

Como se trata de Rust, debe tener en cuenta la propiedad y la vida útil del cierre .

TL; DR; Básicamente, existen 3 tipos de cierres (objetos invocables):

1. Fn: No puede modificar los objetos que captura.
2. FnMut: Puede modificar los objetos que captura.
3. FnOnce: El más restringido. Solo se puede llamar una vez porque cuando se llama se consume a sí mismo y sus capturas.

Consulte ¿ Cuándo implementa un cierre Fn, FnMut y FnOnce? para más detalles

Si está utilizando un cierre simple de puntero a función, entonces el conjunto de captura está vacío y tiene el Fnsabor.

Si quieres hacer cosas más sofisticadas, entonces tendrás que usar funciones lambda.

En Rust hay punteros adecuados para funciones, que funcionan igual que los de C. Su tipo es, por ejemplo fn(i32) -> i32. El Fn(i32) -> i32, FnMut(i32) -> i32y FnOnce(i32) -> i32en realidad son rasgos. Un puntero a una función siempre implementa los tres, pero Rust también tiene cierres, que pueden o no convertirse en punteros (dependiendo de si el conjunto de captura está vacío) a funciones, pero implementan algunos de estos rasgos.

Entonces, por ejemplo, el ejemplo anterior se puede expandir:

fn fun_test_impl(value: i32, f: impl Fn(i32) -> i32) -> i32 {
    println!("{}", f(value));
    value
}
fn fun_test_dyn(value: i32, f: &dyn Fn(i32) -> i32) -> i32 {
    println!("{}", f(value));
    value
}
fn fun_test_ptr(value: i32, f: fn(i32) -> i32) -> i32 {
    println!("{}", f(value));
    value
}

fn times2(value: i32) -> i32 {
    2 * value
}

fn main() {
    let y = 2;
    //static dispatch
    fun_test_impl(5, times2);
    fun_test_impl(5, |x| 2*x);
    fun_test_impl(5, |x| y*x);
    //dynamic dispatch
    fun_test_dyn(5, &times2);
    fun_test_dyn(5, &|x| 2*x);
    fun_test_dyn(5, &|x| y*x);
    //C-like pointer to function
    fun_test_ptr(5, times2);
    fun_test_ptr(5, |x| 2*x); //ok: empty capture set
    fun_test_ptr(5, |x| y*x); //error: expected fn pointer, found closure
}

Fn, FnMutY FnOnce, se indica en la otra respuesta, son de cierre tipos. Los tipos de funciones que se cierran sobre su alcance.

Además de pasar cierres, Rust también admite pasar funciones simples (sin cierre), como esta:

fn times2(value: i32) -> i32 {
    2 * value
}

fn fun_test(value: i32, f: fn(i32) -> i32) -> i32 {
    println!("{}", f (value));
    value
}

fn main() {
    fun_test (2, times2);
}

fn(i32) -> i32aquí hay un tipo de puntero de función .

Si no necesita un cierre completo, trabajar con tipos de funciones suele ser más sencillo, ya que no tiene que lidiar con esas bondades de por vida del cierre.