async函数返回Future的生命周期问题：递归Stream实现报错

错误根源 #

你遇到的lifetime may not live long enough错误，核心原因是异步方法捕获的引用生命周期不匹配：

• AsyncFetcher::fetch是异步方法，调用时会捕获&self（即RecStream中fetcher字段的引用），返回的Future会绑定这个引用的生命周期。
• 你定义的State::Processing存储的Pin<Box<dyn Future<Output = String>>>默认要求Future是'static生命周期（不依赖任何外部引用），但捕获了&AsyncFetcher的Future生命周期和RecStream实例绑定，无法满足'static要求，因此编译器报错。
• 自由函数free_fut返回的Future不持有任何外部引用，天生是'static的，所以能正常存储。

解决方案 #

方案一：使用Arc共享所有权（推荐）

通过Arc<AsyncFetcher>让Future持有所有权，摆脱对外部引用的依赖，使Future成为'static的：

use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use futures::{Stream, StreamExt};

struct AsyncFetcher {}

impl AsyncFetcher {
    async fn fetch(&self, request: String) -> String {
        format!("Response({request})")
    }
}

enum State {
    PendingParent,
    ToProcess(Option<String>),
    Processing(Pin<Box<dyn Future<Output = String>>>)
}

struct RecStream {
    parent: Option<Pin<Box<dyn Stream<Item = String>>>>,
    state: State,
    fetcher: Arc<AsyncFetcher>, // 用Arc持有所有权
}

impl RecStream {
    fn new(parent: Pin<Box<dyn Stream<Item = String>>>, fetcher: AsyncFetcher) -> Self {
        Self {
            parent: Some(parent),
            state: State::PendingParent,
            fetcher: Arc::new(fetcher),
        }
    }

    fn with_result(result: String, fetcher: AsyncFetcher) -> Self {
        Self {
            parent: None,
            state: State::ToProcess(Some(result)),
            fetcher: Arc::new(fetcher),
        }
    }
}

impl Stream for RecStream {
    type Item = String;

    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Self::Item>> {
        let ref_mut = self.get_mut();
        // 克隆Arc，Future持有克隆后的所有权，生命周期为'static
        let fetcher_clone = ref_mut.fetcher.clone();
        let future = async move {
            fetcher_clone.fetch("Some str".to_string()).await
        }.boxed();
        
        ref_mut.state = State::Processing(future); // 不再报错
        
        Poll::Pending
    }
}

async fn free_fut() -> String {
    "Free string".to_string()
}

方案二：给State添加生命周期绑定

如果不想用Arc，可以通过给State和RecStream添加生命周期参数，让Future的生命周期与实例绑定：

use std::pin::Pin;
use std::task::{Context, Poll};
use futures::{Stream, StreamExt};

struct AsyncFetcher {}

impl AsyncFetcher {
    async fn fetch(&self, request: String) -> String {
        format!("Response({request})")
    }
}

// 给State添加生命周期参数，关联Future持有的引用生命周期
enum State<'a> {
    PendingParent,
    ToProcess(Option<String>),
    Processing(Pin<Box<dyn Future<Output = String> + 'a>>)
}

struct RecStream<'a> {
    parent: Option<Pin<Box<dyn Stream<Item = String> + 'a>>>,
    state: State<'a>,
    fetcher: &'a AsyncFetcher, // 存储引用而非所有权
}

impl<'a> RecStream<'a> {
    fn new(parent: Pin<Box<dyn Stream<Item = String> + 'a>>, fetcher: &'a AsyncFetcher) -> Self {
        Self {
            parent: Some(parent),
            state: State::PendingParent,
            fetcher,
        }
    }

    fn with_result(result: String, fetcher: &'a AsyncFetcher) -> Self {
        Self {
            parent: None,
            state: State::ToProcess(Some(result)),
            fetcher,
        }
    }
}

impl<'a> Stream for RecStream<'a> {
    type Item = String;

    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Self::Item>> {
        let ref_mut = self.get_mut();
        // Future生命周期与RecStream的'a一致，可正常存储
        let future = ref_mut.fetcher.fetch("Some str".to_string()).boxed();
        ref_mut.state = State::Processing(future);
        
        Poll::Pending
    }
}

async fn free_fut() -> String {
    "Free string".to_string()
}

该方案的缺点是RecStream带有生命周期参数，会限制其使用场景（比如无法放在需要'static的上下文）。

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