design-patterns - Rust 中的回调模式

问题描述

希望实现两种风格的回调接口。不可变（不能改变分配回调的结构）和可变（可以改变分配回调的结构）。

type Callback<'a> = dyn FnMut(&'a MyStruct<'a>);
type CallbackMut<'a> = dyn FnMut(&'a mut MyStruct<'a>);

struct MyStruct<'a> {
    callback: &'a Callback<'a>,
    callback_mut: &'a CallbackMut<'a>
}

impl<'a> MyStruct<'a> {
    pub fn new(callback: &'a Callback<'a>, callback_mut: &'a CallbackMut<'a>) -> MyStruct<'a> {
        MyStruct {
            callback,
            callback_mut,
        }
    }

    pub fn trigger_callback(&'a self) {
        (self.callback)(self);
    }

    pub fn trigger_callback_mut(&'a mut self) {
        (self.callback_mut)(self);
    }
}

#[cfg(test)]
mod tests {
    use crate::minimal::*;

    #[test]
    fn it_works() {

        let mut triggered1 = false;
        let callback = |_my_struct: &MyStruct| {
            triggered1 = true;
        };

        let mut triggered2 = false;
        let callback_mut = |_my_struct: &mut MyStruct| {
            triggered2 = true;
        };

        let mut my_struct = MyStruct::new(&callback, &callback_mut);
        my_struct.trigger_callback();
        my_struct.trigger_callback_mut();
        assert!(triggered1, "Should call immutable callback");
        assert!(triggered2, "Should call mutable callback");
    }
}

所以我试图了解如何使这种模式在 Rust 中工作，并且对如何解决以下几个编译器错误感到困惑。

如何使用分配的回调并将结构传递给它？还有哪些其他更适合 Rust 的模式可用于执行此操作？

error[E0596]: cannot borrow `*self.callback_mut` as mutable, as it is behind a `&` reference
  --> src/minimal.rs:22:9
   |
6  |     callback_mut: &'a CallbackMut<'a>
   |                   ------------------- help: consider changing this to be mutable: `&'a mut CallbackMut<'a>`
...
22 |         (self.callback_mut)(self);
   |         ^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable

如何改变回调中捕获的变量？还有哪些其他更适合 Rust 的模式可用于执行此操作？

error[E0597]: `triggered1` does not live long enough
  --> src/minimal.rs:35:13
   |
34 |         let callback = |_my_struct: &MyStruct| {
   |                        ----------------------- value captured here
35 |             triggered1 = true;
   |             ^^^^^^^^^^ borrowed value does not live long enough
...
43 |         let mut my_struct = MyStruct::new(&callback, &callback_mut);
   |                                           --------- cast requires that `triggered1` is borrowed for `'static`
...
48 |     }
   |     - `triggered1` dropped here while still borrowed

似乎我应该能够执行一个不可变借用的操作，然后当不可变借用直到可变借用才存在时，该操作是一个可变借用操作。

error[E0502]: cannot borrow `my_struct` as mutable because it is also borrowed as immutable
  --> src/minimal.rs:45:9
   |
44 |         my_struct.trigger_callback();
   |         --------- immutable borrow occurs here
45 |         my_struct.trigger_callback_mut();
   |         ^^^^^^^^^^--------------------^^
   |         |         |
   |         |         immutable borrow later used by call
   |         mutable borrow occurs here

然后我将如何引用在回调中增加的变量？

error[E0503]: cannot use `triggered1` because it was mutably borrowed
  --> src/minimal.rs:46:17
   |
34 |         let callback = |_my_struct: &MyStruct| {
   |                        ----------------------- borrow of `triggered1` occurs here
35 |             triggered1 = true;
   |             ---------- borrow occurs due to use of `triggered1` in closure
...
43 |         let mut my_struct = MyStruct::new(&callback, &callback_mut);
   |                                           --------- cast requires that `triggered1` is borrowed for `'static`
...
46 |         assert!(triggered1, "Should call immutable callback");
   |                 ^^^^^^^^^^ use of borrowed `triggered1`

编辑：一些附加信息。

希望在状态机中实现挂钩功能，从而我可以在事件上调用挂钩 - 状态进入、状态退出、边缘遍历。

不可变回调示例

let mut collected_values = Vec::new();
let immutable_callback_example = |my_struct: &MyStruct| {
    collected_values.push(my_struct.some_val.clone());
};
# run through a bunch of code that might call the trigger_callback an arbitrary number of times
# Do something with the collected values - report out etc

let mut my_structs = Vec::new();
let immutable_callback_example = |my_struct: &MyStruct| {
# Some event indicates we need to create a new struct
    state_machines.push(MyStruct {
      -10,
      callback,
      callback_mut,
    });
};
# run through a bunch of code that might call the trigger_callback an arbitrary number of times
# Do something with the final collection of structs - report out etc

可变回调示例

let mut collected_values = Vec::new();
let mutable_callback_example = |my_struct: &mut MyStruct| {
    collected_values.push(my_struct.some_val.clone());
# Wrap this back around to 0
    if my_struct.some_val > 10 {
        my_struct.some_val = 0;
    }
};
# run through a bunch of code that might call the trigger_callback_mut an arbitrary number of times
# Again, report out

标签： design-patternsrustcallbackborrow-checker

解决方案

FnMut必须能够自行变异，因此您将无法使用 immutable &dyn FnMut。你需要&mut dyn FnMut.

但最大的问题是您过度使用临时引用。&在 Rust 中，并不等同于在其他语言中“通过引用”使用对象，它的语义具有相当严重的局限性。在 99% 的情况下，在结构中使用引用是错误的。

要“通过引用”存储某些内容，您应该使用Box类型，例如Box<dyn FnMut()>. 它是内存中的指针，与完全一样&，但它没有尝试指向单个范围，并且不会用生命周期注释和借用检查器限制“感染”代码。

同样，要在回调函数内部和外部访问一些数据，您需要将这些数据包装在Arc而不是使用&. 对于可变访问：Arc<Mutex>. 对于布尔值，Arc<AtomicBool>也可以。

通过引用捕获局部变量的闭包不能在变量范围之外使用，这通常使得它们无法用于观察者和基于事件的回调编程模式。

不要将临时引用放在结构中。
将所有内容包装在Arc、 clone中Arc，并使用move ||闭包。

design-patterns - Rust 中的回调模式

问题描述

解决方案

推荐阅读