为什么通过移动捕获弧使我的关闭 FnOnce 不是 Fn

Question

在下面的示例中，我使用 Arc 从请求处理程序中引用服务器状态，但编译器将闭包设为 FnOnce。感觉就像我在做正确的事情，因为每个闭包都拥有对状态的强烈引用。为什么这不起作用？有哪些选择可以让它发挥作用？像Share Arc between closures 这样的其他问题表明这样的工作，但我正在制作如图所示的每个闭包克隆，但仍然出现错误。

#![feature(async_closure)]

#[derive(Default, Debug)]
struct State {}

impl State {
    pub async fn exists(&self, key: &str) -> bool {
        true
    }

    pub async fn update(&self, key: &str) {}
}

#[tokio::main]
async fn main() {
    use warp::Filter;
    use std::sync::Arc;

    let state: Arc<State> = Arc::default();

    let api = warp::post()
        .and(warp::path("/api"))
        .and(warp::path::param::<String>().and_then({
            let state = Arc::clone(&state);
            async move |p: String| {
                let x = state.exists(&p);
                if x.await {
                    Ok(p)
                } else {
                    Err(warp::reject::not_found())
                }
            }
        }))
        .and_then({
            let state = Arc::clone(&state);
            async move |id: String| {
                state.update(&id).await;
                Result::<String, warp::Rejection>::Ok("".to_owned())
            }
        });

    warp::serve(api).run(([127, 0, 0, 1], 0)).await;
}

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
  --> src/main.rs:25:13
   |
23 |           .and(warp::path::param::<String>().and_then({
   |                                              -------- the requirement to implement `Fn` derives from here
24 |               let state = Arc::clone(&state);
25 |               async move |p: String| {
   |  _____________^^^^^^^^^^^^^^^^^^^^^^_-
   | |             |
   | |             this closure implements `FnOnce`, not `Fn`
26 | |                 let x = state.exists(&p);
27 | |                 if x.await {
28 | |                     Ok(p)
...  |
31 | |                 }
32 | |             }
   | |_____________- closure is `FnOnce` because it moves the variable `state` out of its environment

Answer 1

嗯，异步闭包是不稳定的，所以这可能是一个错误。我认为当异步块捕获Arc 时，它会消耗它，因此实际上只能调用一次闭包。我的意思是，异步闭包是某种生成器：每次调用它时，它都会构造一个未来，而未来会保留捕获的值。

作为一种解决方法，您可以编写如下内容：

let state = Arc::clone(&state);
move |p: String| {
    let state = Arc::clone(&state);
    async move {
        let x = state.exists(&p);
        //...
    }
}

在闭包内但在 async 块之前进行另一个克隆可确保您可以根据需要多次调用闭包。

我认为实际上Warp::Filter 应该接受FnOnce 开头，但我不知道warp 足以确定。