如何在函数返回的async closure中捕获变量？

原实现方案（Boxed Future模式） #

通过返回boxed future的方式，可在每次调用闭包时显式克隆捕获的值，从而支持多次调用：

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

pub struct Request {}

pub trait HandlerFunc: Send + Sync + Fn(Request) -> Pin<Box<dyn Future<Output = ()> + Send>> {}

impl<F> HandlerFunc for F
where
    F: Send + Sync + Fn(Request) -> Pin<Box<dyn Future<Output = ()> + Send>>,
{}

fn create_handler(v: String) -> impl HandlerFunc {
    move |_req: Request| {
        let v = v.clone(); // 每次调用闭包时显式克隆变量
        Box::pin(async move {
            println!("{}", v);
        })
    }
}

#[tokio::main]
async fn main() {
    let cb = create_handler("Hello World".to_string());
    cb(Request{}).await;
    cb(Request{}).await;
}

尝试Async闭包简化遇到的问题 #

Rust 1.85引入的async闭包语法看似能简化代码，但直接使用会触发编译错误：async闭包无法实现Fn trait，因为它会捕获环境状态并转移所有权，导致只能被调用一次。

use std::future::Future;

pub struct Request {}

pub trait HandlerFunc:
    Sized + Send + Sync + Copy + 'static + Fn(Request) -> Self::OutputFuture
{
    type OutputFuture: Future<Output = ()> + Send;
}

impl<F, Fut: Future<Output = ()> + Send> HandlerFunc for F
where
    F: Sized + Send + Sync + Copy + 'static + Fn(Request) -> Fut,
{
    type OutputFuture = Fut;
}

fn handler(v: i32) -> impl HandlerFunc {
    // 错误：async闭包无法实现`Fn`，因为它捕获了环境状态
    async move |_req: Request| {
        println!("{}", v) // i32实现了Copy，但async move闭包会转移所有权
    }
}

#[tokio::main]
async fn main() {
    let cb = handler(42);
    cb(Request {}).await;
    cb(Request {}).await;
}

解决方案：实现支持多次调用的Async闭包 #

要让async闭包支持多次调用，核心是确保每次调用时都能获取到捕获值的独立副本，同时满足trait约束。

1. 针对Copy类型（如i32） #

利用Copy类型的特性，不使用move关键字，让闭包捕获变量的共享引用（因变量会被闭包环境复制持有，满足'static约束），闭包本身会自动实现Copy：

use std::future::Future;

pub struct Request {}

pub trait HandlerFunc:
    Sized + Send + Sync + Copy + 'static + Fn(Request) -> Self::OutputFuture
{
    type OutputFuture: Future<Output = ()> + Send;
}

impl<F, Fut: Future<Output = ()> + Send> HandlerFunc for F
where
    F: Sized + Send + Sync + Copy + 'static + Fn(Request) -> Fut,
{
    type OutputFuture = Fut;
}

fn handler(v: i32) -> impl HandlerFunc {
    // 捕获Copy类型变量，闭包自动实现Copy
    async |_req: Request| {
        println!("{}", v)
    }
}

#[tokio::main]
async fn main() {
    let cb = handler(42);
    cb(Request {}).await;
    cb(Request {}).await;
}

2. 针对需要Clone的类型（如String） #

对于非Copy类型，可将变量包装在Arc中，利用Arc的轻量克隆特性实现共享所有权，每次调用闭包时克隆Arc指针即可：

use std::future::Future;
use std::sync::Arc;

pub struct Request {}

pub trait HandlerFunc:
    Sized + Send + Sync + Copy + 'static + Fn(Request) -> Self::OutputFuture
{
    type OutputFuture: Future<Output = ()> + Send;
}

impl<F, Fut: Future<Output = ()> + Send> HandlerFunc for F
where
    F: Sized + Send + Sync + Copy + 'static + Fn(Request) -> Fut,
{
    type OutputFuture = Fut;
}

fn handler(v: String) -> impl HandlerFunc {
    let v = Arc::new(v);
    async move |_req: Request| {
        let v_clone = Arc::clone(&v);
        println!("{}", v_clone);
    }
}

#[tokio::main]
async fn main() {
    let cb = handler("Hello World".to_string());
    cb(Request {}).await;
    cb(Request {}).await;
}

3. 保持原克隆逻辑的Async闭包写法 #

若希望保留原代码中每次调用时克隆变量的逻辑，可结合普通闭包与async块的写法，既实现原逻辑，又简化代码（无需手动Box::pin）：

use std::future::Future;

pub struct Request {}

pub trait HandlerFunc:
    Sized + Send + Sync + 'static + Fn(Request) -> Self::OutputFuture
{
    type OutputFuture: Future<Output = ()> + Send;
}

impl<F, Fut: Future<Output = ()> + Send> HandlerFunc for F
where
    F: Sized + Send + Sync + 'static + Fn(Request) -> Fut,
{
    type OutputFuture = Fut;
}

fn handler(v: String) -> impl HandlerFunc {
    move |_req: Request| async move {
        let v = v.clone();
        println!("{}", v);
    }
}

#[tokio::main]
async fn main() {
    let cb = handler("Hello World".to_string());
    cb(Request {}).await;
    cb(Request {}).await;
}

总结 #

可以使用async闭包实现该功能，根据捕获变量的类型选择对应方案：

• 对于Copy类型，直接使用不带move的async闭包即可；
• 对于非Copy类型，使用Arc共享所有权，或在闭包内部显式克隆变量；
• 也可结合普通闭包与async块的写法，保持原克隆逻辑的同时简化代码。

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