无法放宽Trait Object生命周期：Rust异步代码编译错误问询

问题代码 #

use tokio; // 1.7.1
use futures::future::Future;
use std::pin::Pin;
use futures::FutureExt;
use std::marker::PhantomData;
use std::marker::Send;
use std::sync::Arc;
use async_trait::async_trait;

struct Orchestrator {
    worker: Box<dyn WorkerT<Box<dyn Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync>> + Send + Sync>
}

impl Orchestrator {
    async fn other_things(&self, num: i32) -> i32{
        // Do some async stuff in here
        num+1
    }
    
    async fn main_stuff(self: Arc<Self>) {
        let func = |num: i32| {
            let slf = self.clone();
            async move {
                slf.other_things(num).await
            }.boxed()
        };
        
        self.worker.do_work(Box::new(func)).await;
    }
}

#[async_trait]
trait WorkerT<F: Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync> {
    async fn do_work(& self, func: F);
}

struct Worker<F: Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync> {
    phantom: std::marker::PhantomData<F>
}

#[async_trait]
impl<F: Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync> WorkerT<F> for Worker<F> {
    async fn do_work(& self, func: F) {
        for i in 0..5 {
            func(i).await;
        }
    }
}


#[tokio::main]
async fn main() {
    let orchestrator = Arc::new(Orchestrator { worker: Box::new(Worker { phantom: PhantomData }) });
    orchestrator.main_stuff().await;
}

编译错误 #

error[E0597]: `self` does not live long enough
  --> src/main.rs:22:23
   |
21 |         let func = |num: i32| {
   |                    ---------- value captured here
22 |             let slf = self.clone();
   |                       ^^^^ borrowed value does not live long enough
...
28 |         self.worker.do_work(Box::new(func)).await;
   |                             -------------- cast requires that `self` is borrowed for `'static`
29 |     }
   |     - `self` dropped here while still borrowed

问题分析 #

dyn WorkerT trait对象默认带有'static生命周期约束，导致main_stuff方法中传递给do_work的闭包必须满足'static要求，但闭包捕获的Arc<Orchestrator>无法保证该生命周期，从而触发错误。若将worker字段改为具体类型Worker代码可正常运行，但希望保留trait对象的抽象形式，尝试为Orchestrator添加自定义生命周期时，编译器提示生命周期必须长于'static，无法解决问题。

解决方案 #

核心是修改trait WorkerT的定义，引入生命周期参数，让trait对象可以接受非'static的闭包，同时调整Orchestrator的字段类型适配该生命周期。修改后代码如下：

use tokio; // 1.7.1
use futures::future::Future;
use std::pin::Pin;
use futures::FutureExt;
use std::sync::Arc;
use async_trait::async_trait;

// 为WorkerT添加生命周期参数'a，约束闭包的生命周期
#[async_trait]
trait WorkerT<'a> {
    async fn do_work(&self, func: Box<dyn Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync + 'a>);
}

struct Orchestrator<'a> {
    // 使用带生命周期'a的WorkerT trait对象，不再强制'static
    worker: Box<dyn WorkerT<'a> + Send + Sync + 'a>
}

impl<'a> Orchestrator<'a> {
    async fn other_things(&self, num: i32) -> i32 {
        num + 1
    }

    async fn main_stuff(self: Arc<Self>) {
        let func = move |num: i32| {
            let slf = self.clone();
            async move {
                slf.other_things(num).await
            }.boxed()
        };

        self.worker.do_work(Box::new(func)).await;
    }
}

struct Worker;

#[async_trait]
impl<'a> WorkerT<'a> for Worker {
    async fn do_work(&self, func: Box<dyn Fn(i32) -> Pin<Box<dyn Future<Output = i32> + Send>> + Send + Sync + 'a>) {
        for i in 0..5 {
            func(i).await;
        }
    }
}

#[tokio::main]
async fn main() {
    let orchestrator = Arc::new(Orchestrator { worker: Box::new(Worker) });
    orchestrator.main_stuff().await;
}

修改说明 #

1. 为trait WorkerT添加生命周期参数：将原泛型参数F替换为带生命周期约束的dyn Fn类型，让trait对象可接受任意生命周期的闭包，摆脱'static限制。
2. 绑定Orchestrator与trait对象的生命周期：为Orchestrator添加生命周期'a，并将worker字段的trait WorkerT对象绑定到该生命周期，确保闭包生命周期与Orchestrator一致。
3. 简化Worker结构体：原Worker的泛型参数不再需要，因为trait WorkerT直接接受带生命周期的闭包类型，无需通过泛型传递。

修改后代码可正常编译运行，同时保留了trait WorkerT的抽象形式，满足使用trait对象的需求。

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