我在尝试实现Future时遇到了一个障碍。
我需要在我的poll函数中poll另一个async函数，它只接受&str。它看起来像这样：

async fn make_query(query: &str) -> i32 {
    // Magic happens
    5
}

字符串
由于这是一个来自另一个库的函数，我不能简单地改变它的签名来获得值的所有权。
现在我的结构Executor，我想实现Future，它包含一个String，当调用make_query时应该引用它：

struct Executor {
    query: String,
    future: Mutex<Option<Pin<Box<dyn Future<Output = i32>>>>>
}

impl Future for Executor {
    type Output = i32;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let mut lock = self.future.lock().unwrap();

        if let None = *lock {
            // This is where the error occurs
            *lock = Some(Box::pin(make_query(&self.query)))
        }

        let future = lock.as_mut().unwrap();
        pin!(future).poll(cx)
    }
}

型
现在，这样做的目的是我可以.await my Executor自动进行查询：

#[tokio::main]
async fn main() {
    let result = Executor {
        query: "foo".to_string(),
        future: Mutex::new(None)
    }.await;

    println!("Result is {result}");
}

型
现在，显然Mutex要求传递给它的每个引用都是'static？我收到了这些错误消息：

error: lifetime may not live long enough
  --> src/main.rs:23:26
   |
16 |     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
   |                       - let's call the lifetime of this reference `'1`
...
23 |             *lock = Some(Box::pin(make_query(&self.query)))
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cast requires that `'1` must outlive `'static`

error[E0597]: `self` does not live long enough
  --> src/main.rs:23:47
   |
16 |     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
   |             ---- binding `self` declared here
...
23 |             *lock = Some(Box::pin(make_query(&self.query)))
   |                          ---------------------^^^^--------
   |                          |                    |
   |                          |                    borrowed value does not live long enough
   |                          cast requires that `self` is borrowed for `'static`
...
29 |     }
   |     - `self` dropped here while still borrowed

型
如何告诉Rust Executor只有在被完全轮询时才会被丢弃？我不能改变poll的函数签名，因为这会违反trait规范。
或者，更有可能的是，做我想做的事情的正确方法是什么？
这里有一个playground的链接。
PS：我知道调用.await来执行查询可能会被认为是一种“反模式”。

溶液

查看drewtato's answer以获得解释。
解决方案（对我来说）是从我的结构体中删除future字段：

struct Executor {
    query: String
}

型
然后，不实现Future，而是实现IntoFuture，当使用.await时，它会被隐式调用。在这里，我们可以使用async move {}来移动值，而不仅仅是引用它。
注意，此时type IntoFuture = impl Future是不稳定的，因此我不得不使用Pin<Box<dyn Future>>

impl IntoFuture for Executor {
    type Output = i32;
    type IntoFuture = Pin<Box<dyn Future<Output = Self::Output>>>;

    fn into_future(self) -> Self::IntoFuture {
        Box::pin(async move {
            make_query(&self.query).await
        })
    }
}

型
现在你可以在Executor上调用.await：

#[tokio::main] 
async fn main() {
    let res = Executor {
        query: "foo".into()
    }.await;

    println!("Result is {res}"); // 5
}

型