Rust中Future生命周期与函数参数的Trait绑定问题

问题根源 #

async fn的本质是生成带高阶生命周期的函数：for<'a> fn(&'a str) -> impl Future<Output = ()> + 'a，返回的Future生命周期与输入字符串的生命周期强绑定。而你最初的Foo trait实现仅针对fn(&str) -> Fut这类无生命周期关联的函数指针，无法匹配带生命周期绑定的impl Future，因此强制转换时触发E0605错误。

稳定版解决方案 #

方案1：修改Foo trait，让关联类型绑定输入生命周期 #

重新定义trait Foo，使返回的Future关联类型与输入字符串的生命周期绑定：

use std::future::Future;

trait Foo {
    // 关联类型绑定输入生命周期，确保Future的生命周期不超过输入字符串
    type Future<'a>: Future<Output = ()> where Self: 'a;
    fn bar(&self, a: &str) -> Self::Future<'_>;
}

// 为所有符合签名的闭包/函数实现Foo
impl<F> Foo for F
where
    F: for<'a> Fn(&'a str) -> impl Future<Output = ()> + 'a,
{
    type Future<'a> = impl Future<Output = ()> + 'a;
    fn bar(&self, a: &str) -> Self::Future<'_> {
        self(a)
    }
}

// 测试用async fn
async fn test(s: &str) {
    println!("{}", s);
}

fn main() {
    // 无需强制转换，直接传递test即可调用bar
    Foo::bar(&test, "Hello world");
}

方案2：为带高阶生命周期的函数指针实现Foo #

如果不想修改原Foo trait，可以调整实现的约束，适配带生命周期绑定的函数指针：

use std::future::Future;

trait Foo {
    type Future: Future<Output = ()>;
    fn bar(&self, a: &str) -> Self::Future;
}

// 针对带高阶生命周期的函数指针实现Foo
impl<Fut> Foo for for<'a> fn(&'a str) -> Fut<'a>
where
    Fut<'a>: Future<Output = ()>,
{
    type Future = Fut<'_>;
    fn bar(&self, a: &str) -> Self::Future {
        self(a)
    }
}

async fn test(s: &str) {
    println!("{}", s);
}

fn main() {
    Foo::bar(&test, "Hello world");
}

Nightly版简化方案 #

启用Nightly的async_fn_in_trait和return_position_impl_trait_in_trait特性，可以直接在trait中定义async方法，无需手动关联生命周期：

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

use std::future::Future;

trait Foo {
    async fn bar(&self, a: &str);
}

// 为符合条件的函数实现Foo
impl<F> Foo for F
where
    F: for<'a> Fn(&'a str) -> impl Future<Output = ()> + 'a,
{
    async fn bar(&self, a: &str) {
        self(a).await;
    }
}

async fn test(s: &str) {
    println!("{}", s);
}

fn main() {
    let _ = Foo::bar(&test, "Hello world");
}

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