Cursive: closures with static lifetime

help
1

Hi there,

I am new to Rust and I am struggling finding a way around the static lifetime constraint set for callbacks in the Cursive library (i.e. add_global_callback, and thereafter button). Looks like another user raised a similar help request recently. I have tried to provide a fully reproducible example, adapted from Cursive's main repo.

From some of the related discussions, I understand I can use smart pointers as a way around the static constraint. I had a go at this using RefCell, unfortunately with no luck...

use cursive::event::{Event, Key};
use cursive::traits::*;
use cursive::views::{Dialog, EditView, OnEventView, TextArea};
use cursive::Cursive;
use std::cell::RefCell;

struct Item {
  name: String
}

fn main() {
    let mut siv = Cursive::default();
    let item = RefCell::new(Item { name: "some name".to_string() });

    siv.add_layer(
        Dialog::new()
            .title("Describe your issue")
            .padding((1, 1, 1, 0))
            .content(TextArea::new().with_id("text"))
            .button("Ok", Cursive::quit),
    );

    siv.add_layer(Dialog::info("Hint: press Ctrl-F to find in text!"));

    siv.add_global_callback(Event::CtrlChar('f'), |s| {
        s.add_layer(
            OnEventView::new(
                Dialog::new()
                    .title("Change item")
                    .content(
                        EditView::new()
                            .with_id("edit")
                            .min_width(10),
                    )
                    .button("Ok", move |s| {
                        let text =
                            s.call_on_id("edit", |view: &mut EditView| {
                                view.get_content()
                            }).unwrap();
                        *item.borrow_mut() = Item {
                           name: text.to_string()
                        }; 
                    })
                    .dismiss_button("Cancel"),
            ).on_event(Event::Key(Key::Esc), |s| {
                s.pop_layer();
            }),
        )
    });

    siv.run();
}

This doesn't compile:

error[E0373]: closure may outlive the current function, but it borrows `item`, which is owned by the current function
  --> examples/text_area.rs:30:51
   |
30 |     siv.add_global_callback(Event::CtrlChar('f'), |s| {
   |                                                   ^^^ may outlive borrowed value `item`
...
47 |                         *item.borrow_mut() = Item {
   |                          ---- `item` is borrowed here
help: to force the closure to take ownership of `item` (and any other referenced variables), use the `move` keyword
   |
30 |     siv.add_global_callback(Event::CtrlChar('f'), move |s| {
   |                                                   ^^^^^^^^

When I try to follow the compiler tip and the move keyword, I endup with another error:

error[E0507]: cannot move out of captured outer variable in an `FnMut` closure
  --> examples/text_area.rs:42:35
   |
15 |     let item = RefCell::new(Item { name: "some name".to_string() });
   |         ---- captured outer variable
...
42 |                     .button("Ok", move |s| {
   |                                   ^^^^^^^^ cannot move out of captured outer variable in an `FnMut` closure
2

You can use an Rc to ref-count the item, then you move a clone inside the inner closure. Something like this:

let item = Rc::new(RefCell::new(Item {
    name: "some name".to_string(),
}));
...
siv.add_global_callback(Event::CtrlChar('f'), move |s| {
    let item = item.clone();
    ...
}

P.s.: I don't know in the real case, but here you could use a Cell instead of a RefCell, avoiding some runtime overhead and letting the compiler help you in some cases.

3

Hi @dodomorandi

Just did what you suggested:

  • wrapped the RefCell into an Rc.
  • added the move keyword to the first callback
 siv.add_global_callback(Event::CtrlChar('f'), move |s| {
        s.add_layer(
            OnEventView::new(
                Dialog::new()
                    .title("Find")
                    .content(
                        EditView::new()
                            .with_id("edit")
                            .min_width(10),
                    )
                    .button("Ok", |s| {
                        let _text =
                            s.call_on_id("edit", |view: &mut EditView| {
                                view.get_content()
                            }).unwrap();
                        item.clone().replace(Item {
                          name: "updated name".to_string()
                        });
                    })

Unfortunately compilation still fails:

   Compiling cursive v0.9.1-alpha.0 (file:///Users/andrfior/code/Cursive)
error[E0597]: `*item` does not live long enough
  --> examples/text_area.rs:48:25
   |
43 |                     .button("Ok", |s| {
   |                                   --- capture occurs here
...
48 |                         item.clone().replace(Item {
   |                         ^^^^ borrowed value does not live long enough
   |
   = note: borrowed value must be valid for the static lifetime...
note: ...but borrowed value is only valid for the lifetime  as defined on the body at 31:51
  --> examples/text_area.rs:31:51
   |
31 |     siv.add_global_callback(Event::CtrlChar('f'), move |s| {
   |                                                   ^^^^^^^^

error: aborting due to previous error

This points to the second, nested callback. Should I clone the Rc twice? once for each scope...

4

Sorry for not being clear enough, the cloning of the Rc is inside the outer closure, and the clone is moved inside the inner, in the following way:

// Here the item is moved inside
siv.add_global_callback(Event::CtrlChar('f'), move |s| {
    // Now the original `item` is shadowed, and `item` refers to a cloned Rc
    let item = item.clone();
    s.add_layer(
        OnEventView::new(
            Dialog::new()
                .title("Change item")
                .content(EditView::new().with_id("edit").min_width(10))
                // Here we are moving the clone
                .button("Ok", move |s| {
                    let text = s.call_on_id("edit", |view: &mut EditView| view.get_content())
                        .unwrap();
                    item.set(Item {
                        name: text.to_string(),
                    });
                })
                .dismiss_button("Cancel"),
        ).on_event(Event::Key(Key::Esc), |s| {
            s.pop_layer();
        }),
    )
});
5

Got it!

Thanks a lot for your answer and clarification @dodomorandi. this unblocks me!

6

I wanted to thank @dodomorandi, too. I've been wrestling with a similar problem for a while and this post led me to use Rc with a RefCell and be able to move a mutatable copy of a struct into a closure and then still access that closure later.

I know it sounds like a little thing, but I have fought through several non-solutions. Thanks to the community.

7

Step-by-step guide to writing closures with the right bounds

  1. When you need 'static, the closure should have a move annotation;

    • When you don't have a 'static bound, such as with iterator adapters or ::crossbeam::thread::scope, no move is required, and instead of reference counting, classic references suffice.

      • When the closure must be Fn, only shared references (& _) can be used, hence excluding mutation unless interior mutability is used (e.g., RefCell, RwLock);

      • Otherwise, (FnMut and FnOnce closures), both shared (& _) and unique (&mut _) references can be used.

  2. If you still need access from outside the move closure to a captured variable, the best solution is reference counting:

    • Rc when in a single-threaded scenario (such as ::cursive's event loop);

    • Arc otherwise (such as with ::std::thread::spawn());

      • This situation can be spotted thanks to a Send bound on the closure;

    • Then, instead of

      move |/* args */| {
    /* uses captured_var */
}

      the closure becomes

      {
   let captured_variable = Arc::clone(&captured_variable); // or Rc::clone
   move |/* args */| {
       /* uses captured_variable */
   }
}

  3. If you need mutation, you then need interior mutability:

7 Likes
8

To add to what @Yandros said you can read my blog about closures

1 Like