rust FnMut lifetime without use move - rust

Question

I tried to use FnMut for callback, store in struct with Box , but lifetime issues and mutable issues can't be resolved.
I'm a JavaScript programmer, used to using callback functions, the code structure may not be suitable.
struct S {
f: Box<dyn FnMut(i32)>,
}
impl S {
fn new<F: FnMut(i32) + 'static>(f: F) -> S {
S { f: Box::new(f) }
}
fn start(&mut self) {
(*self.f)(2);
(*self.f)(3);
}
}
fn main() {
let mut i: i32 = 1;
let mut s: S = S::new(|x| {
println!("{} + {} = {}", i, x, i + x);
i = i + x;
});
s.start();
println!("i = {}", i);
}
the compiler show the errors:
error[E0373]: closure may outlive the current function, but it borrows `i`, which is owned by the current function
--> src\main.rs:16:27
|
16 | let mut s: S = S::new(|x| {
| ^^^ may outlive borrowed value `i`
17 | println!("{} + {} = {}", i, x, i + x);
18 | i = i + x;
| - `i` is borrowed here
|
note: function requires argument type to outlive `'static`
--> src\main.rs:16:20
|
16 | let mut s: S = S::new(|x| {
| ____________________^
17 | | println!("{} + {} = {}", i, x, i + x);
18 | | i = i + x;
19 | | });
| |______^
help: to force the closure to take ownership of `i` (and any other referenced variables), use the `move` keyword
|
16 | let mut s: S = S::new(move |x| {
| ++++
error[E0502]: cannot borrow `i` as immutable because it is also borrowed as mutable
--> src\main.rs:21:24
|
16 | let mut s: S = S::new(|x| {
| - --- mutable borrow occurs here
| ____________________|
| |
17 | | println!("{} + {} = {}", i, x, i + x);
18 | | i = i + x;
| | - first borrow occurs due to use of `i` in closure
19 | | });
| |______- argument requires that `i` is borrowed for `'static`
20 | s.start();
21 | println!("i = {}", i);
| ^ immutable borrow occurs here
|
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
expect result
1 + 2 = 3
3 + 3 = 6
i = 6

Answer 1

fn new<F: FnMut(i32) + 'static>(f: F) -> S
In this context, the 'static lifetime annotation means that the actual type of F may not be declared to own any references, unless those references refer to values that have static lifetime.
However, the closure you pass captures the outer variable i by reference, which does not have static lifetime. Therefore, the generic lifetime bound 'static is not satisfied.
There's a few ways you can fix this. One would be to have S take a lifetime parameter, which will enable giving it closures that reference data with a non-static lifetime:
struct S<'a> {
f: Box<dyn FnMut(i32) + 'a>,
}
impl<'a> S<'a> {
fn new<F: FnMut(i32) + 'a>(f: F) -> S<'a> {
S { f: Box::new(f) }
}
fn start(&mut self) {
(*self.f)(2);
(*self.f)(3);
}
}
Note that you also have to drop s before you can print i because s owns a mutable borrow of i; the mutable borrow can't coexist with an immutable borrow. You can drop s using std::mem::drop() or by declaring it in a new scope that ends before you access i. For example, using the second approach:
fn main() {
let mut i: i32 = 1;
{
let mut s: S = S::new(|x| {
println!("{} + {} = {}", i, x, i + x);
i = i + x;
});
s.start();
} // s is dropped here, releasing the mutable borrow of i
println!("i = {}", i);
}
(Playground)
Where possible, this should be the preferred approach because it adds no runtime overhead.
A second approach that is less restrictive but has runtime overhead would be using Rc in combination with Cell. This approach explicitly gives you in Rust what you have implicitly in JavaScript: shared ownership of values.1 To accomplish this, the value exists outside of any of the Rc values (on the heap) which are reference-counted handles to the value.
To make this work, Cell is required to provide interior mutability, as you can't get a mutable reference out of an Rc unless only one Rc exists for the value it handles, which isn't the case here. Cell circumvents this, allowing you to set the contained value even if multiple Rcs exist.
Here's an example of how this would apply to this situation, using an Rc<Cell<i32>>. We clone the Rc once and move the clone into the closure. Now both the closure and main() have an Rc to the same value. The inner i32 value will be destroyed when the last Rc sharing ownership of it is destroyed.
(Note this uses the definition and implementation of S verbatim from your question, which works because an owned Rc doesn't count as a reference. This means the closure will satisfy the 'static constraint since it doesn't contain any references at all.)
use std::cell::Cell;
use std::rc::Rc;
// Definition and implementation of S omitted
fn main() {
let i = Rc::new(Cell::new(1i32));
let i2 = i.clone();
let mut s: S = S::new(move |x| {
println!("{} + {} = {}", i2.get(), x, i2.get() + x);
i2.set(i2.get() + x);
});
s.start();
// Dropping s isn't required in this case; both i and i2 can
// coexist without any problems.
println!("i = {}", i.get());
}
(Playground)
1 What you have in JavaScript would actually be closer to Rc<RefCell<T>> than Rc<Cell<T>>. Additionally, most JavaScript runtimes don't do reference counting, but instead some type of mark-and-sweep garbage collection. This is meant to be a comparison about ownership semantics and not a true one-to-one comparison of all possible aspects of JavaScript's object model.