Set struct method as callback - callback

Question

I have some struct and want a method of this struct to be a callback. I tried to set the callback as a closure and call the method in it, but this does not work.
Here is example of what I want. In this example I use the Cursive library:
extern crate cursive;
use cursive::Cursive;
use cursive::views::{BoxView, SelectView, IdView};
use cursive::view::Selector;
struct SomeStruct {
siv: Cursive,
}
impl SomeStruct {
fn new(siv: Cursive) -> SomeStruct {
let mut ss = SomeStruct {
siv: siv
};
let mut select: SelectView<i32> = SelectView::new();
select.set_on_submit(|siv, value| ss.on_submit_callback(siv, value));
ss.siv.add_fullscreen_layer(BoxView::with_full_screen(IdView::new("select", select)));
ss
}
fn on_submit_callback(&mut self, siv: &mut Cursive, value: &i32) {
println!("value - {}", value);
}
}
fn main() {
let siv = Cursive::new();
let mut ss = SomeStruct::new(siv);
}
There are compiler errors:
error[E0373]: closure may outlive the current function, but it borrows `ss`, which is owned by the current function
--> src/main.rs:20:34
|
20 | select.set_on_submit(|siv, value| ss.on_submit_callback(siv, value));
| ^^^^^^^^^^^^ -- `ss` is borrowed here
| |
| may outlive borrowed value `ss`
|
help: to force the closure to take ownership of `ss` (and any other referenced variables), use the `move` keyword, as shown:
| select.set_on_submit(move |siv, value| ss.on_submit_callback(siv, value));
error[E0387]: cannot borrow data mutably in a captured outer variable in an `Fn` closure
--> src/main.rs:20:47
|
20 | select.set_on_submit(|siv, value| ss.on_submit_callback(siv, value));
| ^^
|
help: consider changing this closure to take self by mutable reference
--> src/main.rs:20:34
|
20 | select.set_on_submit(|siv, value| ss.on_submit_callback(siv, value));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors

Answer 1

Rust is not very callback-friendly, to be honest.
Callbacks are easy in garbage-collected languages, as sharing an object is an issue, but tend to be more difficult in languages where ownership is explicit. In this case, you have two possibilities:
event managers,
plowing on with shared ownership.
The latter is easy enough for small applications, but can become really messy (and leaky) at a larger scale. Still, let's start by it.
The most direct translation of Python would be to use shared ownership: a reference counted pointer Rc, wrapping some Cell or RefCell (to defer borrow-checking to run-time).
fn new(siv: Cursive) -> Rc<RefCell<SomeStruct>> {
let mut ss = Rc::new(RefCell::new(SomeStruct {
siv: siv
}));
let mut select: SelectView<i32> =
Rc::new(RefCell::new(SelectView::new()));
{
let weak = ss.clone().downgrade();
select.borrow_mut().set_on_submit(|siv, value|
weak.upgrade()
.map(|ss| ss.borrow_mut().on_submit_callback(siv, value))
);
}
ss.borrow_mut().siv.add_fullscreen_layer(
BoxView::with_full_screen(IdView::new("select", select))
);
ss
}
So, let's get our ownership story straight:
ss owns (partly) select,
select has a weak reference to ss.
The weak reference is necessary to break the cycle, as this would leak.
This solution should work, but as mentioned:
it's a bit clunky syntax-wise,
it's a bit complicated to keep track of where to use Weak to break the cycles,
if you try borrowing twice from RefCell at the same time, one borrow being mutable, you'll get a panic.
In short: it works, but it's not nice.
The other solution is to use a event manager instead.
Event loops are an easy solution to decouple ownership: instead of directly calling on_submit_callback in the callback, push an event to the event manager!
The solution is a bit more involved:
you need something to own SomeStruct (and probably other),
an ID system (you pass an ID instead of a pointer),
an event manager that can retrieve a component by ID to dispatch an event to it,
...
On the other hand, it works pretty well and a decoupled system can be easier to interact with.