Rust中的回调：从痛苦到优雅的惯用之道

引言：为什么Rust中的回调既是挑战（也是机遇）

如果你曾经写过JavaScript、Python或C#，那么回调对你来说是一种熟悉的工具。你传递一个稍后会被调用的函数，然后一切正常。但当你进入Rust的世界时，这个简单的模式突然变成了雷区：所有权、借用、生命周期、dyn vs impl...

在Stack Overflow上，"Idiomatic callbacks in Rust"这个问题获得了数千次浏览。这意味着即使是经验丰富的开发者也会在这个主题上遇到困难。但好消息是：Rust提供了不止一种，而是多种优雅的方式来实现回调。今天我们将逐一分析它们——从简单的闭包到强大的trait对象和枚举模式。

本文适合以下读者：

\n
• 刚开始学习Rust，希望了解如何正确组织异步和事件驱动架构；
\n
• 从其他语言迁移过来，寻找熟悉模式的惯用替代方案；
\n
• 希望编写干净、安全且高性能的Rust代码。
\n

让我们开始吧！

问题：简单的回调有什么问题？

假设我们正在编写一个简单的任务调度器。在Python中，它看起来像这样：

def schedule(callback):\n    # 做点什么\n    callback(result)

在Rust中，第一次尝试可能是这样的：

fn schedule(callback: fn(i32) -> i32) {\n    let result = 42;\n    callback(result);\n}

这确实有效！但仅限于函数，而非闭包。尝试传递一个捕获变量的闭包：

let factor = 2;\nlet closure = |x| x * factor;\nschedule(closure); // 错误！期望函数指针，发现闭包

编译器合理地报错：fn是一个函数指针，而闭包是一个可以捕获环境的匿名类型。我们需要更灵活的方法。

方法1：使用impl Fn的闭包（简单与灵活）

最简单且最常用的方法是使用带有Fn、FnMut或FnOnce trait的泛型类型。

何时使用Fn、FnMut、FnOnce？

\n
• FnOnce —— 如果回调只被调用一次（消耗捕获的值）；
\n
• FnMut —— 如果回调可以修改捕获的状态（被多次调用）；
\n
• Fn —— 如果回调不修改状态（纯函数）。
\n

使用impl Fn的示例：

fn schedule<F>(callback: F)\nwhere\n    F: Fn(i32) -> i32,\n{\n    let result = 42;\n    println!("结果: {}", callback(result));\n}\n\nfn main() {\n    let factor = 2;\n    let closure = |x| x * factor;\n    schedule(closure); // 有效！\n    \n    // 也可以传递普通函数\n    fn double(x: i32) -> i32 { x * 2 }\n    schedule(double);\n}

优点： 最大灵活性，支持闭包，安全，可读性强。
\n缺点： 单态化——对于每种闭包类型，编译器都会生成一个单独的函数版本。如果回调很多，代码可能会膨胀。

方法2：Trait对象 Box<dyn Fn>（动态分发）

如果你想在集合中存储回调（例如在Vec中）或在线程之间传递它们，泛型就不适用了——需要单一类型。这时trait对象就派上用场了：

type Callback = Box<dyn Fn(i32) -> i32>;\n\nstruct Scheduler {\n    callbacks: Vec<Callback>,\n}\n\nimpl Scheduler {\n    fn new() -> Self {\n        Scheduler { callbacks: Vec::new() }\n    }\n    \n    fn register(&mut self, callback