Rust中异步函数作为参数传入时的类型不匹配错误解决

问题代码 #

async fn do_sth_else(_ref: &str, _db: &DatabaseConnection) -> Result<i32, AppError> {
    // do something else
    Ok(15)
}

async fn do_sth<Fut>(
    _ref: &str,
    _db: &DatabaseConnection,
    _f: impl FnOnce(&str, &DatabaseConnection) -> Fut,
) -> Result<&'static str, AppError>
where
    Fut: Future<Output = Result<i32, AppError>>,
{
    // do something
    Ok("something")
}

// call the function
async fn call_both_functions(s: String, db: DatabaseConnection) -> Result<&'static str, AppError> {
    let result = do_sth(&s, &db, do_sth_else).await?;
    Ok(result)
}

错误信息 #

error[E0308]: mismatched types
  --> src/lib.rs:23:18
   |
23 |     let result = do_sth(&s, &db, do_sth_else).await?;
   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected opaque type `impl for<'a, 'b> Future<Output = Result<i32, AppError>>`
              found opaque type `impl Future<Output = Result<i32, AppError>>`
   = help: consider `await`ing on both `Future`s
   = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
  --> src/lib.rs:12:51
   |
12 |     _f: impl FnOnce(&str, &DatabaseConnection) -> Fut,
   |                                                   ^^^

错误原因 #

核心是生命周期约束不匹配：

• do_sth_else作为异步函数，返回的Future会绑定输入参数（&str和&DatabaseConnection）的生命周期；
• do_sth中对_f的FnOnce约束未明确要求它能处理任意生命周期的输入引用，导致Rust无法推断泛型Fut与输入参数生命周期的关联，最终触发类型不匹配。

修复方案 #

方案1：使用高阶生命周期（HRTB）约束闭包

直接在FnOnce类型上添加for<'a, 'b>高阶生命周期，明确要求闭包兼容任意生命周期的输入引用，并返回对应生命周期的Future：

use std::future::Future;

async fn do_sth(
    _ref: &str,
    _db: &DatabaseConnection,
    _f: impl for<'a, 'b> FnOnce(&'a str, &'b DatabaseConnection) -> impl Future<Output = Result<i32, AppError>>,
) -> Result<&'static str, AppError>
{
    // 若需要调用传入的异步函数，可添加：
    // let inner_result = _f(_ref, _db).await?;
    Ok("something")
}

方案2：显式绑定泛型生命周期

给do_sth添加生命周期参数，将泛型Fut的生命周期与输入参数的生命周期绑定，明确关联关系：

use std::future::Future;

async fn do_sth<'a, 'b, Fut>(
    _ref: &'a str,
    _db: &'b DatabaseConnection,
    _f: impl FnOnce(&'a str, &'b DatabaseConnection) -> Fut,
) -> Result<&'static str, AppError>
where
    Fut: Future<Output = Result<i32, AppError>> + 'a + 'b,
{
    // 若需要调用传入的异步函数，可添加：
    // let inner_result = _f(_ref, _db).await?;
    Ok("something")
}

方案选择 #

• 方案1更简洁，适合不需要单独操作Fut类型的场景；
• 方案2更灵活，若后续需要对Fut添加更多泛型约束或逻辑，推荐使用。

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