我可以将函数作为参数传递吗？如果没有，有什么好的选择？
我尝试了一些不同的语法，但我没有找到正确的语法。我知道我可以做到：
fn example() {
let fun: fn(value: i32) -> i32;
fun = fun_test;
fun(5i32);
}
fn fun_test(value: i32) -> i32 {
println!("{}", value);
value
}
但这并不是将函数作为参数传递给另一个函数：
fn fun_test(value: i32, (some_function_prototype)) -> i32 {
println!("{}", value);
value
}
【问题讨论】：
标签： rust
当然可以：
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, ×2);
}
由于这是 Rust，您必须考虑到 ownership and lifetime of the closure。
TL;DR;基本上有 3 种类型的闭包（可调用对象）：
Fn：不能修改捕获的对象。FnMut：它可以修改它捕获的对象。FnOnce：最受限制的。只能调用一次，因为调用时它会消耗自身及其捕获。详情请见When does a closure implement Fn, FnMut and FnOnce?
如果您使用的是像闭包这样简单的指向函数的指针，那么捕获集是空的，并且您具有 Fn 风格。
如果你想做更多花哨的东西，那么你将不得不使用 lambda 函数。
在 Rust 中有正确的指向函数的指针，它们的工作方式与 C 中的一样。它们的类型例如是 fn(i32) -> i32。 Fn(i32) -> i32、FnMut(i32) -> i32 和 FnOnce(i32) -> i32 实际上是特征。指向函数的指针总是实现所有这三个，但 Rust 也有闭包，可能会或可能不会转换为指向函数的指针（取决于捕获集是否为空），但它们确实实现了其中一些特征。
例如，上面的例子可以展开：
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, ×2);
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* 是特征，所以通常的 <T: Trait> 与 (t: &T) 都适用。非泛型解决方案的主要限制是它必须与引用一起使用。所以如果你想要FnOnce，它应该作为副本传递，你必须使用通用样式。
<F: Fn..> 而不是 (f: &Fn...)。这是有原因的 - 泛型将导致静态调度，而 trait 对象需要动态调度。
FnOnce 实际上是最通用的特征——它接受所有闭包，无论它们是读取、修改还是取得所有权的捕获状态。 FnMut 更具限制性，它不接受获取捕获对象所有权的闭包（但它仍然允许修改状态）。 Fn 是最严格的，因为它不接受修改其捕获状态的闭包。因此，要求&Fn 对funTest 调用者的限制最大，而对如何在其中调用f 的限制最小。
Fn、FnMut 和 FnOnce，在另一个答案中概述，是 closure 类型。超出其范围的函数类型。
除了传递闭包之外，Rust 还支持传递简单（非闭包）函数，如下所示：
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) -> i32 这里是function pointer type。
如果您不需要一个成熟的闭包，那么使用函数类型通常会更简单，因为它不必处理那些闭包生命周期的细节。
【讨论】：