cannot move out of a captured variable in an async `Fn` closure

Here is my code. In this program, I want to create a simple websocket server. When user sends a request to the ws://{url}/, the browser will establish a websocket connection with the server.

use std::{collections::HashMap, sync::Arc};

use async_std::{prelude::*, sync::Mutex};
use tide_websockets::WebSocket;
use uuid::Uuid;

#[async_std::main]
async fn main() {
    let connections = Arc::new(Mutex::new(HashMap::new()));
    let mut app = tide::new();
    app.at("/").get(WebSocket::new(move |_, mut stream| async move {
        let uuid = Uuid::new_v4();

        // Add the connection to clients when opening a new connection
        connections.lock().await.insert(uuid, stream.clone());

        // Waiting for the connection to be closed
        while let Some(Ok(_)) = stream.next().await {}

        // Remove the connection from clients when it is closed
        connections.lock().await.remove(&uuid);

        Ok(())
    }));

    // app.bind(url).await
}

When I tried to compile this program, the rustc said:

error[E0507]: cannot move out of `connections`, a captured variable in an `Fn` closure
  --> src/main.rs:11:57
   |
9  |       let connections = Arc::new(Mutex::new(HashMap::new()));
   |           ----------- captured outer variable
10 |       let mut app = tide::new();
11 |       app.at("/").get(WebSocket::new(move |_, mut stream| async move {
   |  ____________________________________--------------------_^
   | |                                    |
   | |                                    captured by this `Fn` closure
12 | |         let uuid = Uuid::new_v4();
13 | |
14 | |         // Add the connection to clients when opening a new connection
15 | |         connections.lock().await.insert(uuid, stream.clone());
   | |         -----------
   | |         |
   | |         variable moved due to use in generator
   | |         move occurs because `connections` has type `Arc<async_std::sync::Mutex<HashMap<Uuid, WebSocketConnection>>>`, which does not implement the `Copy` trait
...  |
23 | |         Ok(())
24 | |     }));
   | |_____^ move out of `connections` occurs here

For more information about this error, try `rustc --explain E0507`.
error: could not compile `mre` due to previous error

And this is the definition of the Websocket::new method (no sure if it's useful):

impl<S, H, Fut> WebSocket<S, H>
where
    S: Send + Sync + Clone + 'static,
    H: Fn(Request<S>, WebSocketConnection) -> Fut + Sync + Send + 'static,
    Fut: Future<Output = Result<()>> + Send + 'static,
{
    /// Build a new WebSocket with a handler function that
    pub fn new(handler: H) -> Self {
        Self {
            handler: Arc::new(handler),
            ghostly_apparition: PhantomData,
            protocols: Default::default(),
        }
    }

    // ...
}

I tried searching this problem before posting this question. Most of the answers are either irrelevant, or need to modify the source code of the method (Websocket::new method here). But this method is not written by me but is from a third-party crate. Is there still any way to resolve this problem?

The argument of WebSocket::new() has to be an Fn closure, meaning, it must be callable repeatedly.

In your code, however, it internally uses the connections variable inside of an async move, meaning it moves the variable into the async block. This can for obvious reasons only be done once.

It's easy to fix, though. Instead of moving the entire connections variable in, you need to create a new Arc reference of the connections variable and move that one into the async move. So every invocation gets its own copy of it, making it compatible with Fn.

Here is a compiling version:

use std::{collections::HashMap, sync::Arc};

use async_std::{prelude::*, sync::Mutex};
use tide_websockets::WebSocket;
use uuid::Uuid;

#[async_std::main]
async fn main() {
    let connections = Arc::new(Mutex::new(HashMap::new()));
    let mut app = tide::new();
    app.at("/").get(WebSocket::new(move |_, mut stream| {
        let connections = Arc::clone(&connections);
        async move {
            let uuid = Uuid::new_v4();

            // Add the connection to clients when opening a new connection
            connections.lock().await.insert(uuid, stream.clone());

            // Waiting for the connection to be closed
            while let Some(Ok(_)) = stream.next().await {}

            // Remove the connection from clients when it is closed
            connections.lock().await.remove(&uuid);

            Ok(())
        }
    }));

    // app.bind(url).await
}