如何实现JavaScript风格的回调

Question

我正在尝试实现一个JavaScript风格的回调。我有一个使用库的应用程序（两者都是我的），我需要该应用程序能够将闭包或函数传递给库中的方法，然后该方法生成一个线程，当满足条件时，它将在线程内部调用回调。

main.rs

fn main(){
    welcome_message();
    mylib::connect(|| println!("Connected to service! Please enter a command. (hint: help)nn"));
    loop {
        match prompt_input() {
            true => {},
            false => break,
        }
    }
}

lib.rs

pub fn connect<F>(resolve: F) -> (mpsc::Sender<Message>, mpsc::Receiver<Message>)
    where F: Fn()
{
    ...
    let receive_loop = Thread::scoped(move || {
        for response in receiver.incoming_messages::<Message>(){
            let json_string = match response.unwrap() {
                Message::Text(txt) => txt,
                _ => "".to_string(),
            };
            let message = json::Json::from_str(json_string.as_slice());
            let message_json = message.unwrap();
            if message_json.is_object() {
                let ref something = receiver_tx;
                let obj = message_json.as_object().unwrap();
                let something_json = obj.get("lsri").unwrap();
                let something = something_json.to_string().replace(""", "");
                match something.as_slice() {
                    "service#connected" => resolve(),
                    _ => println!("{}", type),
                }
            } else {
                println!("Invalid service response");
            }
        }
    });
    ...
}

错误

src/lib.rs:54:24: 54:38 error: the trait `core::marker::Send` is not implemented for the type `F` [E0277]
src/lib.rs:54     let receive_loop = Thread::scoped(move || {
                                     ^~~~~~~~~~~~~~
src/lib.rs:54:24: 54:38 note: `F` cannot be sent between threads safely
src/lib.rs:54     let receive_loop = Thread::scoped(move || {
                                     ^~~~~~~~~~~~~~

它不需要是我传递的闭包，我也可以传递函数。它不需要任何参数或返回类型，但如果有帮助的话，我可以添加一些伪参数。我对实现同一目标的其他方法或方法的建议持开放态度。

我尝试过使用：

• 线程：：生成
• FnMut（）
• Arc:：new（resolve）（带有.clone（）的实现）
• Arc:：new（互斥：：new（resolve））（带有.lock（）的实现）
• 在谷歌上搜索示例
• 完整阅读《铁锈》一书
• 在错误消息中搜索示例
• 以上所有配置均不同

Rust有可能做到这一点吗？有更好的方法吗？

感谢您提前抽出时间。

解决方案：

对于将来发现这一点的人，根据下面答案的说明，我将connect的签名更改为以下内容，这允许回调传递到线程中。

pub fn connect<'a, T, F>(resolve: F) -> (mpsc::Sender<Message>, mpsc::Receiver<Message>)
    where T: Send + 'a, F: FnOnce() -> T, F: Send + 'a

Answer 1

尝试使用与Thread:：scoped:相同的限制标记F

fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> 
    where T: Send + 'a, F: FnOnce() -> T, F: Send + 'a

具体来说，用Send特性来界定类型应该可以清除的即时错误

对于类型F 不实现特征core::marker::Send