Captured variable cannot escape FnMut closure body

[MMK]

code that causes error:

pub fn main() {
let mut a=vec![11,34,12];

let mut cl=||{a.push(15);a.last().unwrap()};

}

But when I change it to it, the error disappears:

pub fn main() {
let mut a=vec![11,34,12];

let mut cl=||{a.last().unwrap()};

}

I have fully read and understand the meaning of the error, but why does it occur only in the first case?

[khimru]

First version modifies vector which means it has unique mutable reference to it. Unique references are, well… unique. And thus you can not return shared reference to the element because it would clash with unique mutable reference to the whole vector.

Second version doesn't change anything, it's only receives shared read-only reference… and these can be easily copied around.

[jofas]

@khimru

Second version doesn't change anything, it's only receives shared read-only reference… and these can be easily copied around.

This works thanks to reborrowing (I think):

Why can I assign a mutable reference to an immutable reference without violating the borrowing rules?

The following code (it compiles!) first declares a mutable variable s which has the type String. Then it creates r1 which is a mutable reference to s. Later on, it assigns r1 to r2 which is an immutable reference to s by coercing r1 into type &String and it even assign r2 to r3 which is another immutable reference to s. Isn't the reference scope of r1 fully covers the reference scopes of r2 and r3 since there is a p1.push_str("ghi") statement at the end, so it violates the borrowing rules? To fu…

[quinedot]

FnMut closures can only return a single type, including lifetimes, so the situation is similar to this:

// Compiles
struct JustLast<'a>(&'a Vec<i32>);
impl<'a> JustLast<'a> {
    fn call(&self) -> Option<&'a i32> {
        self.0.last()
    }
}

// Fails
struct PushThenLast<'a>(&'a mut Vec<i32>);
impl<'a> PushThenLast<'a> {
    fn call_mut(&mut self) -> Option<&'a i32> {
        self.0.push(15);
        self.0.last()
    }
}

You can get a &'long _ out from a &'short self.0 by copying, and thus always return an Option<&'a i32> in the case of JustLast. But you can only get a &'short mut _ out from &'short mut self in the case of PushThenLast.

This signature would work:

    fn call_mut(&mut self) -> Option<&i32> {

but the FnMut trait doesn't allow that; it only allows return values independent of the &mut self borrow.

[MMK]

refs live only until their last use, so a unique mutable reference to the vector drop here, isn't it?

[khimru]

What do you mean by “here”? What happens if you call that closure twice?

[quinedot]

I don't know if this is what you meant either, but you can nudge the compiler to create a FnOnce closure instead.

    fn nudge_inferrence<'a, F: FnOnce() -> &'a i32>(f: F) -> F { f }
    let cl = nudge_inferrence(|| {
        a.push(15);
        a.last().unwrap()
    });

This is now analogous to

struct PushThenLast<'a>(&'a mut Vec<i32>);
impl<'a> PushThenLast<'a> {
    fn call_once(self) -> &'a i32 {
        self.0.push(15);
        self.0.last().unwrap()
    }
}

[MMK]

Yes, it makes sense