Rust 程序设计语言

高级函数与闭包

本节将探索一些与函数和闭包相关的高级特性，包括函数指针和返回闭包。

函数指针

我们已经讨论过如何向函数传递闭包；其实也可以向函数传递普通函数！当你想传递一个已经定义好的函数而不是定义一个新闭包时，这个技术就很有用。函数会强转为 fn 类型（小写的 f），注意不要与闭包 trait Fn 混淆。fn 类型被称为函数指针（function pointer）。通过函数指针传递函数，可以让你将函数用作其他函数的参数。

指定参数为函数指针的语法与闭包类似，如示例 20-28 所示，我们定义了一个将参数加 1 的函数 add_one。函数 do_twice 接收两个参数：一个指向任意接收 i32 参数并返回 i32 的函数的函数指针，以及一个 i32 值。do_twice 函数调用函数 f 两次，并将 arg 值传递给它，然后把两次函数调用的结果相加。main 函数以 add_one 和 5 为参数调用 do_twice。

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

fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
    f(arg) + f(arg)
}

fn main() {
    let answer = do_twice(add_one, 5);

    println!("The answer is: {answer}");
}

这段代码会打印 The answer is: 12。我们指定 do_twice 中的参数 f 是一个接收一个 i32 类型参数并返回 i32 的 fn。然后我们可以在 do_twice 的函数体中调用 f。在 main 中，我们可以将函数名 add_one 作为第一个参数传递给 do_twice。

与闭包不同，fn 是一个类型而不是 trait，所以我们直接指定 fn 作为参数类型，而不是以某个 Fn trait 作为 trait 约束来声明泛型类型参数。

函数指针实现了全部三个闭包 trait（Fn、FnMut 和 FnOnce），这意味着你总是可以将函数指针作为参数传递给期望闭包的函数。编写函数时最好使用泛型类型和闭包 trait 之一，这样你的函数可以同时接收函数和闭包。

话虽如此，一个只想接收 fn 而不接收闭包的例子是与没有闭包的外部代码交互时：C 函数可以接收函数作为参数，但 C 没有闭包。

作为一个既可以使用内联定义的闭包又可以使用具名函数的例子，我们来看看标准库中 Iterator trait 提供的 map 方法的用法。要使用 map 方法将数字 vector 转换为字符串 vector，可以使用闭包，如示例 20-29 所示。

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(|i| i.to_string()).collect();
}

或者我们也可以将函数名作为 map 的参数来替代闭包。示例 20-30 展示了这种写法。

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(ToString::to_string).collect();
}

注意，我们必须使用“高级 trait”一节中讨论的完全限定语法，因为有多个名为 to_string 的函数可用。

这里我们使用的是 ToString trait 中定义的 to_string 函数，标准库为任何实现了 Display 的类型都实现了该 trait。

回想一下第 6 章“枚举值”一节的内容，我们定义的每个枚举变体的名字也会成为一个初始化函数。我们可以将这些初始化函数用作实现了闭包 trait 的函数指针，这意味着可以将初始化函数指定为接收闭包的方法的参数，如示例 20-31 所示。

fn main() {
    enum Status {
        Value(u32),
        Stop,
    }

    let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect();
}

这里，我们通过使用 Status::Value 的初始化函数，用 map 所作用范围内的每个 u32 值来创建 Status::Value 实例。有些人偏爱这种风格，有些人则更喜欢使用闭包。它们编译出的代码是相同的，所以请使用对你来说更清晰的风格。

返回闭包

闭包由 trait 表示，这意味着不能直接返回闭包。在大多数想返回 trait 的情况下，可以改用实现了该 trait 的具体类型作为函数的返回值。然而，闭包通常不能这样做，因为它们没有可返回的具体类型；例如，如果闭包捕获了作用域中的任何值，就不允许使用函数指针 fn 作为返回类型。

通常你应该使用第 10 章学过的 impl Trait 语法。你可以使用 Fn、FnOnce 和 FnMut 返回任何函数类型。例如，示例 20-32 中的代码可以正常编译。

#![allow(unused)]
fn main() {
fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}
}

然而，正如我们在第 13 章“闭包类型推断与注解”一节中所指出的，每个闭包也是其独有的类型。如果你需要处理多个签名相同但实现不同的函数，就需要为它们使用 trait 对象。考虑一下如果编写像示例 20-33 那样的代码会发生什么。

fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}

fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
    move |x| x + init
}

这里我们有两个函数 returns_closure 和 returns_initialized_closure，它们都返回 impl Fn(i32) -> i32。注意，它们返回的闭包是不同的，尽管它们实现了相同的类型。如果我们尝试编译这段代码，Rust 会告诉我们这行不通：

$ cargo build
   Compiling functions-example v0.1.0 (file:///projects/functions-example)
error[E0308]: mismatched types
  --> src/main.rs:2:44
   |
 2 |     let handlers = vec![returns_closure(), returns_initialized_closure(123)];
   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected opaque type, found a different opaque type
...
 9 | fn returns_closure() -> impl Fn(i32) -> i32 {
   |                         ------------------- the expected opaque type
...
13 | fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
   |                                              ------------------- the found opaque type
   |
   = note: expected opaque type `impl Fn(i32) -> i32`
              found opaque type `impl Fn(i32) -> i32`
   = note: distinct uses of `impl Trait` result in different opaque types

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions-example` (bin "functions-example") due to 1 previous error

错误信息告诉我们，每当我们返回 impl Trait 时，Rust 都会创建一个独特的不透明类型（opaque type），在这种类型中，我们无法看清 Rust 为我们构造的内容细节，也无法猜测 Rust 会生成什么类型来自己书写。所以，尽管这些函数返回的闭包实现了相同的 trait Fn(i32) -> i32，Rust 为每个函数生成的不透明类型却是不同的。（这类似于 Rust 为不同的 async 块产生不同的具体类型，即使它们有相同的输出类型，正如我们在第 17 章“Pin 类型与 Unpin Trait”中所见。）我们已经多次见过这个问题的解决方案：可以使用 trait 对象，如示例 20-34 所示。

fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

fn returns_initialized_closure(init: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x + init)
}

这段代码可以正常编译。关于 trait 对象的更多信息，请参阅第 18 章“使用 trait 对象抽象共享行为”一节。

接下来，让我们看看宏！