如何在Rust中实现支持异步函数的重试功能？

先看你的异步测试函数：

async fn can_fail() -> Result<i32, Box<dyn std::error::Error>> {
    let mut rng = rand::thread_rng();
    let random: u8 = rng.gen();
    if random % 2u8 == 0 {
        Ok(42)
    } else {
       Err("error".to_string().into())
    }
}

以及你最初编写的同步重试函数：

fn retry<F: Fn() -> Result<i32, Box<dyn std::error::Error>>>(f: F, retries: i32) -> Result<i32, Box<dyn std::error::Error>>
{
    let mut count = 0;
    loop {
        let result = f();

        if result.is_ok() {
            break result;
        } else {
            if count > retries {
             break result
            }
            count += 1;
        }
    }
}

1. 你编写的retry函数是否能正常工作？ #

这个同步retry函数仅能处理返回Result的同步函数，完全无法适配你的异步can_fail函数——因为异步函数调用后返回的是Future而非直接的Result，所以你根本没法把异步函数（或包裹它的闭包）传入。

就算用来处理同步函数，它的重试逻辑也存在问题：count初始值为0，判断条件是count > retries才终止重试。比如设置retries=2，实际会尝试3次（初始1次+2次重试），不符合常规的重试次数预期；且失败后的判断逻辑可以简化，核心是次数判断条件写反了，应该是count >= retries时返回错误。

2. 如何修复await只能在异步函数/块中使用的错误？ #

错误核心是你写的闭包不是异步闭包，且原retry函数是同步的，无法处理异步逻辑。解决需要两步：

第一步：将闭包改为异步闭包

异步闭包的返回值是Future，无需手动指定复杂的装箱类型，让编译器自动推导即可：

let my_closure = || async {
    can_fail().await
};

如果确实需要装箱存储，写法如下（用Box::pin固定Future在内存中，才能被await）：

let my_closure: Box<dyn Fn() -> Pin<Box<dyn Future<Output = Result<i32, Box<dyn std::error::Error>>>>>> = 
    Box::new(|| Box::pin(async {
        can_fail().await
    }));

第二步：将retry函数改为异步函数，支持处理Future

retry函数必须改为异步的，才能在内部await异步任务的结果，调整后的函数如下：

async fn retry<F, Fut, T, E>(mut f: F, retries: u32) -> Result<T, E>
where
    F: FnMut() -> Fut,
    Fut: Future<Output = Result<T, E>>,
    E: std::error::Error + 'static,
{
    let mut attempts = 0;
    loop {
        match f().await {
            Ok(result) => return Ok(result),
            Err(e) => {
                if attempts >= retries {
                    return Err(e);
                }
                attempts += 1;
                // 可选：添加重试间隔，比如 tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            }
        }
    }
}

调用时直接传入异步闭包即可（需在异步上下文，比如标记为async的main函数中）：

let result = retry(|| can_fail(), 3).await;

3. 如何让retry函数更通用？ #

你原来的retry函数硬编码了返回类型，要实现泛型化，只需将返回值的成功类型T和错误类型E设为泛型参数，并添加合适的约束——上面的异步retry函数已经是泛型版本，各参数说明：

• F：闭包类型，约束为FnMut() -> Fut，允许闭包被多次调用（满足重试需求），返回一个Future
• Fut：闭包返回的Future类型，约束为Future<Output = Result<T, E>>，指定Future的最终输出为Result
• T：成功时的返回值类型，支持任意类型
• E：错误类型，约束为std::error::Error + 'static，确保错误可被处理和传递

可以用这个泛型函数处理不同返回类型的异步函数：

// 另一个返回Result<String, Box<dyn Error>>的异步函数
async fn another_fail() -> Result<String, Box<dyn std::error::Error>> {
    let mut rng = rand::thread_rng();
    if rng.gen_bool(0.5) {
        Ok("success".to_string())
    } else {
        Err("another error".to_string().into())
    }
}

// 调用泛型retry
let str_result = retry(|| another_fail(), 2).await;

如果需要支持同步函数的重试，也可以写一个同步泛版retry函数，逻辑类似但无需处理Future：

fn sync_retry<F, T, E>(mut f: F, retries: u32) -> Result<T, E>
where
    F: FnMut() -> Result<T, E>,
    E: std::error::Error + 'static,
{
    let mut attempts = 0;
    loop {
        match f() {
            Ok(result) => return Ok(result),
            Err(e) => {
                if attempts >= retries {
                    return Err(e);
                }
                attempts += 1;
            }
        }
    }
}

内容的提问来源于stack exchange，提问作者Finlay Weber