Rust 在映射中存储异步回调

我试图将多个异步回调存储在一个散列映射中，稍后我将对其进行迭代。这是我最接近于让它工作的尝试，但是，由于回调的生命周期，我得到了一个编译错误

use std::boxed::Box;
use std::collections::HashMap;
use std::future::Future;
use std::pin::Pin;

type AsyncCallback = Box<dyn Fn() -> Pin<Box<dyn Future<Output = ()>>>>;

#[derive(Default)]
pub struct CallbackMap {
    callbacks: HashMap<&'static str, AsyncCallback>,
}

impl CallbackMap {
    pub fn add<C, F>(&mut self, name: &'static str, callback: C)
    where
        C: Fn() -> F,
        C: 'static,
        F: Future<Output = ()> + 'static,
    {
        self.callbacks
            .insert(name, Box::new(|| Box::pin(callback())));
    }

    pub async fn execute(&self) {
        for (_key, value) in &self.callbacks {
            value().await;
        }
    }
}

async fn async_callback() {
    println!("Callback 2");
}

fn main() {
    let mut callbacks = CallbackMap::default();

    callbacks.add("test1", || async {
        println!("Callback 1");
    });

    callbacks.add("test2", async_callback);

    callbacks.execute();
}

---

使用

move

关键字将

callback

移动到闭包中：

self.callbacks
    .insert(name, Box::new(move || Box::pin(callback())));
                        // ^^^^

游乐场连接：

self.callbacks
    .insert(name, Box::new(move || Box::pin(callback())));
                        // ^^^^