为何带可变引用的异步函数无法作为结构体字段传入？

我在开发一个包含异步函数字段的结构体时遇到问题：当异步函数接收可变引用作为参数时，代码无法正常编译，而接收所有权类型参数时可以正常运行。

可正常运行的代码 #

#![allow(dead_code)]

pub struct TestStruct;

struct TestStruct2<F>
where
    F: std::future::Future<Output = ()>,
{
    foo: fn(TestStruct) -> F,
}

async fn foo(_x: TestStruct) {}

#[tokio::main]
async fn main() {
    let _s = TestStruct2 { foo };
}

无法运行的代码 #

#![allow(dead_code)]

pub struct TestStruct;

struct TestStruct2<F>
where
    F: std::future::Future<Output = ()>,
{
    foo: fn(&mut TestStruct) -> F,
}

async fn foo(_x: &mut TestStruct) {}

#[tokio::main]
async fn main() {
    let _s = TestStruct2 { foo }; // 编译错误发生在这里
}

编译错误信息 #

mismatched types
expected fn pointer `for<'r> fn(&'r mut TestStruct) -> _`     
found fn item `for<'r> fn(&'r mut TestStruct) -> impl std::future::Future<Output = ()> {foo}`

问题原因 #

核心矛盾在于异步函数返回的Future类型与参数的生命周期绑定：

• 当异步函数接收的是所有权类型（如TestStruct）时，返回的Future不依赖任何外部引用的生命周期，是'static的。此时结构体的泛型参数F可以直接匹配这个单一的Future类型，fn指针的类型也能完全对齐。
• 当参数是可变引用&mut TestStruct时，异步函数返回的Future会捕获该引用的生命周期'r。换句话说，每个不同的生命周期'r对应一个不同的Future类型。但结构体TestStruct2的泛型参数F是单一固定类型，无法同时适配所有可能的'r。而编译器期望的fn指针需要满足for<'r>的高阶生命周期约束——即对任意生命周期'r，都返回同一个F类型，这和实际异步函数返回的、与'r绑定的impl Future类型完全冲突。

解决方法 #

方法1：使用trait对象装箱Future

通过Pin<Box<dyn Future>>将不同生命周期的Future统一为trait对象，绕过单一类型的限制。这种方法灵活性高，但会带来轻微的运行时开销。

#![allow(dead_code)]

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

pub struct TestStruct;

struct TestStruct2 {
    foo: fn(&mut TestStruct) -> Pin<Box<dyn Future<Output = ()> + '_>>,
}

async fn foo(_x: &mut TestStruct) {}

#[tokio::main]
async fn main() {
    let _s = TestStruct2 {
        foo: |x| Box::pin(foo(x)),
    };
}

方法2：为结构体添加生命周期参数

让结构体的泛型参数F与引用的生命周期绑定，这样就能匹配异步函数返回的、带有对应生命周期的Future。这种方法没有运行时开销，但结构体的生命周期会和引用绑定，使用场景受限。

#![allow(dead_code)]

pub struct TestStruct;

struct TestStruct2<'r, F>
where
    F: std::future::Future<Output = ()> + 'r,
{
    foo: fn(&'r mut TestStruct) -> F,
}

async fn foo(_x: &mut TestStruct) {}

#[tokio::main]
async fn main() {
    let _s: TestStruct2<'_, _> = TestStruct2 { foo };
}

方法3：使用闭包代替fn指针

利用闭包的生命周期捕获特性，将结构体的字段定义为满足高阶生命周期约束的闭包类型。这种方法既灵活又无额外开销，是推荐的方案之一。

#![allow(dead_code)]

pub struct TestStruct;

struct TestStruct2<F>
where
    F: for<'r> FnMut(&'r mut TestStruct) -> impl std::future::Future<Output = ()> + 'r,
{
    foo: F,
}

async fn foo(_x: &mut TestStruct) {}

#[tokio::main]
async fn main() {
    let _s = TestStruct2 { foo };
}

内容的提问来源于stack exchange，提问作者Ivan Raul Sanchez Diaz