Rust中如何接收可选异步闭包？有无无冗余的惯用实现方案？

在Rust中，要实现同时支持同步和异步回调且避免重复代码，最惯用的方式是通过trait抽象统一两种场景的处理逻辑——核心思路是定义一个能将回调返回值转换为最终结果的trait，再为同步结果和异步Future分别实现该trait。

具体实现步骤 #

1. 定义统一转换的Trait #

先定义一个IntoResult trait，它负责将回调的返回值（无论是同步结果还是异步Future）转换为最终的error::Result<usize>：

use futures::{executor::block_on, Future};
use std::error;

trait IntoResult {
    fn into_result(self) -> error::Result<usize>;
}

2. 为同步/异步场景实现Trait #

分别为直接返回error::Result<usize>的同步情况，以及返回Future<Output = error::Result<usize>>的异步情况实现该trait：

// 同步结果直接返回
impl IntoResult for error::Result<usize> {
    fn into_result(self) -> error::Result<usize> {
        self
    }
}

// 异步Future通过block_on执行并返回结果
impl<F> IntoResult for F
where
    F: Future<Output = error::Result<usize>>,
{
    fn into_result(self) -> error::Result<usize> {
        block_on(self)
    }
}

3. 编写通用处理函数 #

编写一个通用函数，接受任意返回值实现了IntoResult的回调，内部统一调用trait方法处理，无需区分同步或异步：

fn handle_callback<TFn, TResult>(callback: TFn) -> error::Result<usize>
where
    TFn: Fn() -> TResult,
    TResult: IntoResult,
{
    callback().into_result()
}

使用示例 #

// 同步回调
fn sync_callback() -> error::Result<usize> {
    Ok(42)
}

// 异步回调
async fn async_callback() -> error::Result<usize> {
    Ok(100)
}

fn main() {
    // 处理同步回调
    let sync_result = handle_callback(sync_callback);
    println!("同步结果: {:?}", sync_result);

    // 处理异步回调
    let async_result = handle_callback(async_callback);
    println!("异步结果: {:?}", async_result);
}

优势说明 #

这种方式完全遵循Rust的抽象设计原则：

• 无需编写重复的分支逻辑处理同步/异步场景
• 通过trait实现了逻辑解耦，后续扩展其他返回类型只需新增trait实现即可
• 调用方无需关心回调是同步还是异步，使用方式完全一致

内容的提问来源于stack exchange，提问作者Dmitriy Kovalenko