如何在`rust_socketio`（异步版本）中使用共享外部变量？

Question

使用普通版即可

use rust_socketio::{ClientBuilder, Payload, RawClient};
use std::sync::mpsc::channel;

fn main() {
    let (tx, rx) = channel::<String>();
    let tx_clone = tx.clone();
    let callback = move |payload: Payload, socket: RawClient| {
        tx_clone.send("...".to_string());
    };
    let callback2 = move |payload: Payload, socket: RawClient| {
        tx.send("...".to_string());
    };
    let socket = ClientBuilder::new("")
        .on("evt1", callback)
        .on("evt2", callback2)
        .connect()
        .expect("Connection failed");
}

但是如果我切换到使用异步版本

use rust_socketio::{
    asynchronous::{Client, ClientBuilder},
    Payload,
};
use std::sync::mpsc::channel;

#[tokio::main]
async fn main() {
    let (tx, rx) = channel::<String>();
    let tx_clone = tx.clone();
    let callback = |payload: Payload, socket: Client| {
        async move {
            tx_clone.send("...".to_string());
        }.boxed()
    };
    let callback2 = |payload: Payload, socket: Client| {
        async move {
            tx.send("...".to_string());
        }.boxed()
    };
    let socket = ClientBuilder::new("")
        .on("evt1", callback)
        .on("evt2", callback2)
        .connect()
        .await
        .expect("Connection failed");
}

使用异步版本我总是收到错误：

expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
this closure implements `FnOnce`, not `FnMut`

不知道如何解决这个问题。也找不到这方面的例子。

我能找到的所有示例都是最简单的，其中回调不需要访问外部变量。

这是

.on()

函数。

 pub fn on<T: Into<Event>, F>(mut self, event: T, callback: F) -> Self
    where
        F: for<'a> std::ops::FnMut(Payload, Client) -> BoxFuture<'static, ()>
            + 'static
            + Send
            + Sync,
    {
        self.on
            .insert(event.into(), Callback::<DynAsyncCallback>::new(callback));
        self
    }

Answer 1

#[tokio::main]
async fn main() {
    let (tx, rx) = channel::<String>();
    let tx2 = tx.clone();
    let socket = ClientBuilder::new("http://localhost:9559")
        .on("evt1", move |payload, socket| {
            let tx = tx.clone();
            async move {
                tx.send(format!("identity: {:?}", payload)).unwrap();
            }
            .boxed()
        })
        // .on("evt1", callback2)
        .on_any(move |evt, payload, socket| {
            let tx = tx2.clone();
            async move {
                tx.send(format!("{:?}", payload)).unwrap();
            }
            .boxed()
        })
        .connect()
        .await
        .expect("Connection failed");
}