Help Understanding Lifetimes

[karmic prism]

struct Foo<'a> {
    s: &'a str,
}

impl<'a> Foo<'a> {
    fn update(&'a mut self) {
        self.s = "asdf";
    }
}

fn main() {
    let mut foo = Foo {
        s: "blah",
    };
    
    foo.update();
    foo.update(); //error: cannot borrow foo as mutable more than once
}

I'm confused why adding the lifetime in the update function makes it so you can't call update twice due to foo already being mutably borrowed...After you call foo.update aren't there no mutable references to foo that exist? it seems like it should be fine to call update again

[tropic iron]

You connected the lifetime of the string to the lifetime of the mutable borrow

?play ```rust
struct Foo<'a> {
s: &'a str,
}

impl<'a> Foo<'a> {
fn update(&mut self) {
self.s = "asdf";
}
}

fn main() {
let mut foo = Foo {
s: "blah",
};

foo.update();
foo.update(); //error: cannot borrow foo as mutable more than once

}

[tropic iron]

So it has to pick one lifetime

[karmic prism]

I guess I'm confused still by the compiler error when calling foo.update the second time...How could foo be mutably borrowed at that time? it would seem to me like no mutable references exist

[tropic iron]

The constraint of &'a mut self forces rustc to consider it still active

[karmic prism]

update then makes a static lifetime mutable borrow?

[tropic iron]

Basically you said while "blah" exists the first borrow also does

(I'm glossing over variance)

[tropic iron]

It's not actually static, but it is for the full lifetime of foo

[karmic prism]

oh this is making a lot of sense now, thank you

[tropic iron]

Because of variance rustc can shrink the lifetime to the scope foo lives in but not shorter

[fleet lake]

So is it something like that &'a mut self's life time will be equal to the life time of str and &'a mut self's lifetime should be valid within the scope of the function (update).?

Is it like that

[fleet lake]

In continuation -> so we need to remove 'a from &mut self

Which means that it doesn't drops at the end of function call .??

  fn update(&'a mut self){

  //  -> &'a mut self doesn't drops here
   } 

[wintry wagon]

you have the &'a mut Type<'a> pattern

which is not useful

[fleet lake]

Oh

[fleet lake]

I mean i don't get what you wrote

[wintry wagon]

the &'a mut self is connected to the &'a str
so you cannot borrow it twice because the mut ref is living for 'static

[fleet lake]

Hm make sence