如何修复接受引用并返回非装箱Future的闭包中的生命周期错误？

问题背景 #

我需要编写一个接受异步闭包的函数，但Rust目前不支持原生异步闭包，因此用返回Future的闭包模拟。初始简化代码如下：

pub async fn serve_request(
    request: Vec<u8>,
    dispatch: impl FnOnce(&[u8]) -> impl Future<Output = Vec<u8>> + Send,
) {
    // 实际代码中调用dispatch前后还有其他逻辑
    dispatch(&request).await;
}

这段代码编译失败，原因是Rust暂不支持在impl trait的返回值中嵌套impl trait。

临时解决方案：装箱Future #

一个简单的修复方式是返回装箱后的Future，通过动态分发绕过嵌套impl trait的限制：

use std::future::Future;
use std::pin::Pin;
use tokio;

pub async fn serve_request_1(
    request: Vec<u8>,
    dispatch: impl FnOnce(&[u8]) -> Pin<Box<dyn Future<Output = Vec<u8>> + Send + '_>>,
) {
    dispatch(&request).await;
}

#[tokio::main]
async fn main() {
    tokio::spawn(serve_request_1(vec![], |payload| {
        Box::pin(async { payload.to_vec() })
    }));
}

这段代码可以正常编译，注意返回的Future需要添加+ '_约束，它是高阶 trait 约束（HRTB）impl for<'a> FnOnce(&'a [u8]) -> Pin<Box<dyn Future<Output = Vec<u8>> + Send + 'a>>的简写，两种写法效果一致。

优化尝试：避免装箱开销 #

为了提升性能，我希望去掉Box::pin()的装箱操作，尝试将返回的impl Future替换为泛型参数：

pub async fn serve_request_2<Fut: Future<Output = Vec<u8>> + Send>(
    request: Vec<u8>,
    dispatch: impl FnOnce(&[u8]) -> Fut,
) {
    dispatch(&request).await;
}

这个函数单独编译没问题，但实际用闭包调用时会触发生命周期错误。我尝试了几种修复方式均无效：

// 编译失败：未使用HRTB约束，无法适配任意输入生命周期
pub async fn serve_request_2<'a, Fut: Future<Output = Vec<u8>> + Send + 'a>(
    request: Vec<u8>,
    dispatch: impl FnOnce(&'a [u8]) -> Fut,
) {
    dispatch(&request).await;
}

// 无效：生命周期'a未声明，无法关联闭包输入和返回值
pub async fn serve_request_2<Fut: Future<Output = Vec<u8>> + Send + 'a>(
    request: Vec<u8>,
    dispatch: impl for<'a> FnOnce(&'a [u8]) -> Fut,
) {
    dispatch(&request).await;
}

// 无效：'_占位符不能用于泛型参数的生命周期约束
pub async fn serve_request_2<Fut: Future<Output = Vec<u8>> + Send + '_>(
    request: Vec<u8>,
    dispatch: impl FnOnce(&[u8]) -> Fut,
) {
    dispatch(&request).await;
}

我无法像使用Box<dyn Future>那样，通过for<'a> FnOnce(&'a [u8]) -> Fut让Fut的生命周期和输入切片的'a绑定。

可行的无装箱解决方案 #

要实现无装箱的异步闭包接收，需要将闭包的返回类型与输入的生命周期关联，通过HRTB（高阶 trait 约束）和生命周期泛型来实现：

方案1：生命周期关联的泛型参数 #

use std::future::Future;
use tokio;

pub async fn serve_request_4<F, Fut>(
    request: Vec<u8>,
    dispatch: F,
) where
    // 对任意生命周期'a，闭包接受&'a [u8]并返回Fut<'a>
    F: for<'a> FnOnce(&'a [u8]) -> Fut<'a>,
    // Fut<'a>是与'a绑定的Future，确保捕获的引用生命周期合法
    Fut<'a>: Future<Output = Vec<u8>> + Send + 'a,
{
    dispatch(&request).await;
}

#[tokio::main]
async fn main() {
    // 调用时无需Box::pin，直接返回async块即可
    tokio::spawn(serve_request_4(vec![], |payload| async { payload.to_vec() }));
}

这里Fut是一个带生命周期参数的类型，HRTB约束F对任意'a都能返回对应生命周期的Fut<'a>，完美匹配闭包返回的async块（它捕获了payload的引用，生命周期与输入切片绑定）。

方案2：用Trait Alias简化约束（Rust 1.65+） #

可以用trait alias将复杂的约束封装起来，让代码更整洁：

use std::future::Future;
use tokio;

// 定义异步闭包的Trait Alias，关联输入生命周期和返回Future
#[rustfmt::skip]
type AsyncDispatchFn<'a> = 
    FnOnce(&'a [u8]) -> impl Future<Output = Vec<u8>> + Send + 'a;

pub async fn serve_request_5<F>(
    request: Vec<u8>,
    dispatch: F,
) where
    // 约束闭包对任意生命周期'a都满足AsyncDispatchFn<'a>
    F: for<'a> AsyncDispatchFn<'a>,
{
    dispatch(&request).await;
}

#[tokio::main]
async fn main() {
    tokio::spawn(serve_request_5(vec![], |payload| async { payload.to_vec() }));
}

这个方案本质和方案1一致，只是通过trait alias简化了约束的写法。

Nightly版本可选方案 #

如果你使用Rust Nightly版本，可以开启async_fn_in_trait和return_position_impl_trait_in_trait特性，直接定义带异步方法的Trait，让闭包自动实现该Trait：

#![feature(async_fn_in_trait)]
#![feature(return_position_impl_trait_in_trait)]

use std::future::Future;
use tokio;

trait Dispatch {
    async fn call(&self, payload: &[u8]) -> Vec<u8>;
}

// 为闭包自动实现Dispatch Trait
impl<F, Fut> Dispatch for F
where
    F: Fn(&[u8]) -> Fut,
    Fut: Future<Output = Vec<u8>> + Send,
{
    async fn call(&self, payload: &[u8]) -> Vec<u8> {
        self(payload).await
    }
}

pub async fn serve_request_6(
    request: Vec<u8>,
    dispatch: impl Dispatch + Send,
) {
    dispatch.call(&request).await;
}

#[tokio::main]
async fn main() {
    tokio::spawn(serve_request_6(vec![], |payload| async { payload.to_vec() }));
}

不过这个方案依赖Nightly特性，稳定版中还是推荐方案1或方案2。

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