CODEWITHSUNDEEP
rust
Jakub M.
Jakub M.

Reputation: 33817

Vector holding mutable functions

I would like to have a vector with functions. Then I would like to iterate on this vector and execute functions one by one. The functions would mutate an external state. Additionally, I would like to be able to place the same function twice in the vector.

The problems I have are:

The closest I got is:

fn main() {
    let mut c = 0;
    {
        let mut f = ||{c += 1};
        let mut v: Vec<&mut FnMut()> = vec![];
        v.push(&mut f);

        // How to execute the stored function? The following complains about
        // an immutable reference:
        //    assignment into an immutable reference
        // (v[0])();

        // How to store the same function twice? The following will fail with:
        //     cannot borrow `f` as mutable more than once at a time
        // v.push(&mut f);
    }
    println!("c {}", c);
}

Upvotes: 1

Views: 158

Answers (1)

Vladimir Matveev
Vladimir Matveev

Reputation: 127711

For the first problem, I don't really know why no mutable dereference happens here (in my opinion, it should), but there is a simple workaround: just do the dereference and then reference manually:

(&mut *v[0])();

Your second problem is more complex, though. There is no simple solution, because what you're trying to do violates Rust aliasing guarantees, and since you did not describe the purpose of it, I can't suggest alternatives properly. In general, however, you can overcome this error by switching to runtime borrow-checking with Cell/RefCell or Mutex (the latter is when you need concurrent access). With Cell (works nice for primitives):

use std::cell::Cell;

fn main() {
    let c = Cell::new(0);
    {
        let f = || { c.set(c.get() + 1); };
        let mut v: Vec<&Fn()> = vec![];
        v.push(&f);
        v.push(&f);

        v[0]();
        v[1]();
    }
    println!("c {}", c.get());
}

With RefCell (works nice for more complex types):

use std::cell::RefCell;

fn main() {
    let c = RefCell::new(0);
    {
        let f = || { *c.borrow_mut() += 1; };
        let mut v: Vec<&Fn()> = vec![];
        v.push(&f);
        v.push(&f);

        v[0]();
        v[1]();
    }
    println!("c {}", *c.borrow());
}

As you can see, now you have &Fn() instead of &mut FnMut(), which can be aliased freely, and whose captured environment may also contain aliased references (immutable, of course).

Upvotes: 3

Related Questions